Wipro Interview Questions & Placement Prep (2026)
Wipro hires through two closely related tracks — Elite NLTH for Project Engineers and Turbo for Junior Associate Software Engineers. Both share a similar backbone: an aptitude block covering quant, logical and verbal reasoning, a written communication (essay) task, and a two-problem coding round, followed by a technical and HR interview (sometimes with a voice/communication assessment). This guide covers the exact section split, syllabus, formulas, previous-year questions, ready-to-use code and a 6-week roadmap.
~48 min aptitude (Quant + Logical + Verbal) + 20 min essay + 60 min coding (2 problems) — roughly 128 minutes total, followed by interviews
Last updated:
Exam Pattern
~48 min aptitude (Quant + Logical + Verbal) + 20 min essay + 60 min coding (2 problems) — roughly 128 minutes total, followed by interviews
| Section | Questions | Time | Type | Difficulty |
|---|---|---|---|---|
| Quantitative Ability | 12–16 | Part of 48-min aptitude block | MCQ | Easy–Medium |
| Logical Reasoning | 12–14 | Part of 48-min aptitude block | MCQ | Medium |
| Verbal Ability | 18–22 | Part of 48-min aptitude block | MCQ | Easy–Medium |
| Written Communication (Essay) | 1 essay | 20 min | Descriptive writing | Non-technical, scored |
| Coding Assessment | 2 problems | 60 min | Coding | Easy–Medium (Elite) / Medium (Turbo) |
Section-Wise Syllabus
Everything that appears in the assessment, grouped by section.
1. Overall Structure — Elite NLTH vs Turbo
Elite NLTH (Project Engineer)
- • ≈48 min aptitude: ~12–16 Quant, ~12–14 Logical, ~18–22 Verbal
- • 20 min written communication (essay, ~200–300 words)
- • 60 min coding — 2 problems
- • Some drives add a voice/communication assessment before interviews
Turbo / Junior Associate SE
- • Similar 16 Quant / 14 Logical / 18 Verbal split reported most often
- • Higher coding expectation and stronger technical screening
- • One essay task, two coding problems (~60 min)
- • Additional business discussion or technical interview round in some drives
Older paper formats (for concept practice only)
- • 60 questions in 70 minutes: technical + logical + verbal MCQs
- • 20 technical MCQs + 20 logical + 20 verbal, all within 70 minutes, coding as a separate round
2. Quantitative Ability
Core topics
- • Number system, HCF & LCM, divisibility and remainders
- • Percentages, profit/loss/discount
- • Ratio & proportion, averages, mixtures & allegations
- • Simple & compound interest
- • Time, speed & distance; trains, boats & streams
- • Time & work, pipes & cisterns, ages
- • Permutation & combination, probability
- • Algebraic equations, geometry & mensuration, data interpretation, clocks & calendars
3. Logical Reasoning
Core topics
- • Number & letter series, coding-decoding, analogy, odd one out
- • Blood relations, direction sense, seating arrangements, puzzles
- • Syllogisms, statement & conclusion, statement & assumption, data sufficiency
- • Venn diagrams, ranking & ordering, cubes & dice, calendar/clock reasoning, input-output
Quick solving rules
- • Blood relations — draw a family tree
- • Direction problems — use x/y coordinates
- • Arrangements — place fixed positions first
- • Syllogisms — use set (Venn) diagrams
- • Data sufficiency — decide sufficiency, don't over-solve
- • Series — check differences, ratios, squares, cubes, alternating terms
4. Verbal Ability
Topics
- • Reading comprehension, sentence correction, error spotting
- • Sentence completion, fill in the blanks, para jumbles
- • Synonyms & antonyms, vocabulary in context
- • Articles, prepositions, conjunctions, tenses, subject–verb agreement
- • Pronouns, modifiers, active/passive voice, direct/indirect speech, idioms, one-word substitution
Grammar checklist
- • Each, every, neither, either — singular verbs
- • Keep subject and verb consistent; use parallel structure in lists
- • 'Fewer' for countable nouns, 'less' for uncountable nouns
- • Avoid dangling modifiers; check preposition necessity
- • In para jumbles, spot the introductory sentence and pronoun references
5. Written Communication (Essay, 20 min)
What is evaluated
- • Grammar
- • Coherence
- • Vocabulary
- • Organisation
- • Ability to express an opinion
- • Professional tone
- • Examples and supporting arguments
Structure & sample topics
- • 4 paragraphs: introduction, main argument, counterpoint/example, conclusion
- • Target 200–300 words; avoid slang, excessive headings, unsupported statistics
- • Sample: Is AI a threat or opportunity? / WFH vs office / social media & students
- • Sample: data privacy, online education, automation & employment, EVs in India, cybersecurity
6. Coding — Project Engineer vs Turbo
Project Engineer basics
- • Input/output, conditions, loops, functions
- • Arrays, strings, sorting, searching, frequency counting
- • Basic math, pattern printing, recursion basics
- • Two-pointer problems, simple hashing, matrix traversal
Turbo / Junior Associate SE additions
- • Prefix sums, sliding window, hash maps
- • Binary search, linked lists, stacks & queues
- • Recursion & backtracking, trees & BSTs, BFS/DFS
- • Greedy algorithms, dynamic programming, heap/priority queue, intervals, GCD & modular arithmetic
Allowed languages
- • C
- • C++
- • Java
- • Python
7. Technical MCQs & Pseudocode (older Elite/Turbo papers)
Topics
- • C/C++/Java basics, operators & precedence, loops, functions
- • Arrays, strings, pointers/references, recursion
- • Output prediction, sorting & searching, OOP, basic data structures, time complexity
Most Asked Topics
Highest-frequency areas across recent test papers.
Aptitude speed
48-minute combined Quant + Logical + Verbal block rewards speed; percentages, time-work, series and RC repeat every drive.
Essay writing
20-minute essay on tech/social topics — grammar, coherence and a clear four-paragraph structure matter more than length.
Sum of odd factors / perfect square / triangle count
Classic Wipro-specific coding questions reported across Turbo drives.
Kadane's max subarray & balanced brackets
Frequently reused coding patterns for both Elite and Turbo coding rounds.
Subarray sum with negatives
Prefix sum + hash map pattern for arrays containing negative numbers.
Number of islands (BFS/DFS)
Common intermediate-level Turbo coding question using grid traversal.
Minimum coins (DP)
Classic dynamic-programming question for Turbo-level rounds.
Process vs thread, polymorphism, normalization
Recurring technical-interview theory questions for both Project Engineer and Turbo.
Free Resources
Curated practice links per section.
Aptitude & Reasoning
Written communication
Coding practice
50+ DSA Practice Problems
Solve in order — arrays and strings first, then sorting and recursion.
Easy — Project Engineer level (10)
- Sum of odd factors of n
- Check whether n is a perfect square
- Count digits, reverse a number
- Check palindrome number/string
- Find Armstrong numbers in a range
- Second-largest element in an array
- Count character frequencies in a string
- Remove duplicate characters from a string
- Rotate an array by k positions
- Pattern printing — number and star patterns
Medium — Turbo level (10)
- Number of possible triangles from given side lengths
- First non-repeating character in a string
- Maximum subarray sum (Kadane's algorithm)
- Balanced brackets using a stack
- Count subarrays with sum K (with negatives) using prefix sum + hash map
- Two Sum using hashing
- Binary search on a sorted array or on the answer
- Detect a cycle in a linked list
- Reverse a linked list
- Count possible triangles with two-pointer technique
Hard — Turbo/JASE stretch problems (8)
- Minimum coins to make a value (DP)
- Number of islands (BFS/DFS on a grid)
- Longest substring without repeating characters (sliding window)
- Topological sort for dependency resolution
- Shortest path in an unweighted graph (BFS)
- Disjoint Set Union for repeated connectivity queries
- Range sum queries using prefix sum
- Range update/query using a Fenwick or segment tree
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
- Find the missing number using the n(n+1)/2 formula
- Reverse words in a sentence
- Anagram check using sorting or hashing
- Count vowels and consonants
Previous Year Questions & Patterns
Repeat coding questions with the expected approach.
Aptitude PYQs
- A train 180 m long crosses a pole in 9 seconds — speed = 72 km/h
- Article marked 25% above cost, sold at 10% discount — profit = 12.5%
- A and B complete work in 12 and 18 days — combined time = 7.2 days
- Series 4, 9, 16, 25, 36, ? — next term = 49
- If CODE is coded as DPEF, how is JAVA coded? → KBWB
Reasoning & verbal PYQs
- All testers are engineers; some engineers are programmers — can we conclude some testers are programmers? → No
- Choose the correct sentence: 'Neither of the solutions are valid' vs 'Neither of the solutions is valid' → the second
- Arrange logically: requirements, design, implementation, testing, deployment
Technical output-prediction
- int x = 2; for (i=1;i<=3;i++) x = x*i; cout<<x; → Output: 12
- for (int i = 1; i <= n; i *= 2) cout << i; → Time complexity O(log n)
Coding PYQs
- Sum of odd factors of n (e.g. n=12 → factors 1,3 → answer 4)
- Check perfect square without floating-point precision errors
- Count triangles from side lengths using sorting + two pointers
- Count subarrays with sum K in an array with negative values
- Minimum number of coins to make a target value
HR & technical interview questions
- Difference between process and thread
- What is polymorphism? Explain virtual functions
- Difference between primary key and foreign key; what is normalization?
- Write a query using JOIN and GROUP BY
- What is a deadlock? Explain stack vs heap memory
- Explain your project's architecture and your individual contribution
- Why Wipro? Are you comfortable relocating or working in shifts?
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
FROM employees;GROUP BY with HAVING
SELECT department, AVG(salary) AS avg_salary
FROM employees
GROUP BY department
HAVING AVG(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 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.
What is normalization?
Structuring tables through 1NF, 2NF, 3NF and BCNF to remove redundancy and update anomalies.
Primary key vs foreign key?
Primary key uniquely identifies a row in its own table; a foreign key references the primary key of another table.
What is a deadlock?
A cycle of processes each waiting on a resource held by another, satisfying 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, making context switching cheaper.
What are ACID properties?
Atomicity, Consistency, Isolation and Durability — the guarantees of a reliable transaction.
Stack vs heap memory?
Stack stores function calls and local variables with automatic cleanup; heap stores dynamically allocated memory managed manually or by GC.
What is indexing?
A lookup structure that speeds up reads at the cost of storage and slower writes/updates.
TCP vs UDP?
TCP is connection-oriented and reliable; UDP is connectionless and faster but without delivery guarantees.
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
Expose only essential features and hide implementation behind interfaces or abstract classes.
Inheritance
Derive a Child class from a Parent to reuse and extend behaviour.
Polymorphism
Compile-time overloading versus runtime overriding (virtual functions in C++, overriding in Java/Python).
Class vs object
A class is the blueprint; an object is an instance holding its own state.
Virtual functions
Enable runtime dispatch in C++; base class pointer calls the derived class implementation.
Time complexity basics
Linear search O(n), binary search O(log n), nested loops O(n²), Kadane's algorithm O(n).
Recursion vs iteration
Recursion trades stack space for cleaner code on divide-and-conquer problems like binary search and tree traversal.
1. Sum of odd factors (C++)
long long sumOfOddFactors(long long n) {
long long sum = 0;
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
if (i % 2 != 0) sum += i;
long long other = n / i;
if (other != i && other % 2 != 0) sum += other;
}
}
return sum;
}2. Perfect square check (C++)
bool isPerfectSquare(long long n) {
long long r = (long long)sqrt((double)n);
for (long long i = max(0LL, r - 2); i <= r + 2; i++) {
if (i * i == n) return true;
}
return false;
}3. Number of triangles (C++)
int countTriangles(vector<int>& a) {
sort(a.begin(), a.end());
int n = a.size(), count = 0;
for (int k = n - 1; k >= 2; k--) {
int i = 0, j = k - 1;
while (i < j) {
if (a[i] + a[j] > a[k]) { count += (j - i); j--; }
else i++;
}
}
return count;
}4. Kadane's maximum subarray (C++)
long long maxSubArraySum(vector<int>& a) {
long long best = a[0], current = a[0];
for (size_t i = 1; i < a.size(); i++) {
current = max((long long)a[i], current + a[i]);
best = max(best, current);
}
return best;
}5. Balanced brackets (C++)
bool isBalanced(string s) {
stack<char> st;
for (char c : s) {
if (c == '(' || c == '[' || c == '{') st.push(c);
else {
if (st.empty()) return false;
char top = st.top(); st.pop();
if ((c == ')' && top != '(') || (c == ']' && top != '[') || (c == '}' && top != '{')) return false;
}
}
return st.empty();
}6. Count subarrays with sum K (C++)
long long countSubarraysWithSumK(vector<int>& a, long long k) {
unordered_map<long long, int> mp;
mp[0] = 1;
long long sum = 0, answer = 0;
for (int x : a) {
sum += x;
answer += mp[sum - k];
mp[sum]++;
}
return answer;
}7. Minimum coins (DP, C++)
int minCoins(vector<int>& coins, int amount) {
vector<int> dp(amount + 1, INT_MAX);
dp[0] = 0;
for (int x = 1; x <= amount; x++) {
for (int c : coins) {
if (c <= x && dp[x - c] != INT_MAX) dp[x] = min(dp[x], dp[x - c] + 1);
}
}
return dp[amount] == INT_MAX ? -1 : dp[amount];
}8. Number of islands — BFS (C++)
int numIslands(vector<vector<char>>& grid) {
int rows = grid.size(), cols = grid[0].size(), count = 0;
vector<pair<int,int>> dirs = {{0,1},{0,-1},{1,0},{-1,0}};
for (int r = 0; r < rows; r++) {
for (int c = 0; c < cols; c++) {
if (grid[r][c] == '1') {
count++;
queue<pair<int,int>> q;
q.push({r, c});
grid[r][c] = '0';
while (!q.empty()) {
auto [cr, cc] = q.front(); q.pop();
for (auto& d : dirs) {
int nr = cr + d.first, nc = cc + d.second;
if (nr >= 0 && nr < rows && nc >= 0 && nc < cols && grid[nr][nc] == '1') {
grid[nr][nc] = '0';
q.push({nr, nc});
}
}
}
}
}
}
return count;
}9. Encapsulation & abstraction (Java)
class BankAccount {
private double balance;
public void deposit(double amount) { balance += amount; }
public double getBalance() { return balance; }
}10. Reverse a linked list (Java)
class ListNode {
int val;
ListNode next;
ListNode(int val) { this.val = val; }
}
ListNode reverseList(ListNode head) {
ListNode prev = null;
while (head != null) {
ListNode next = head.next;
head.next = prev;
prev = head;
head = next;
}
return prev;
}Operating System Basics
Scheduling, deadlock and memory management essentials.
Process & Threads
- • Process has its own memory space; threads within a process share memory.
- • Context switching between processes is costlier than between threads.
- • Mutex vs semaphore; race conditions when shared resources are unsynchronised.
Scheduling & Deadlock
- • FCFS, SJF, SRTF, Round Robin, Priority scheduling.
- • Priority scheduling can cause starvation unless ageing is used.
- • Deadlock requires mutual exclusion, hold-and-wait, no preemption and circular wait.
Memory Management
- • Paging uses fixed-size pages; segmentation uses variable-size logical divisions.
- • Virtual memory relies on demand paging and page replacement (FIFO, LRU, Optimal).
- • Cache stores frequently accessed data to reduce access time.
Networking basics
- • OSI layers and TCP/IP model responsibilities.
- • TCP (connection-oriented, reliable) vs UDP (connectionless, fast).
- • Three-way handshake, DNS resolution, HTTP/HTTPS ports.
4-Week Preparation Roadmap
From zero to test-ready in 28 days.
Percentages, ratios, number system, grammar & C++ basics
- 1 hr Quant (percentages, ratios, number system)
- 45 min Verbal (grammar + RC)
- 1 hr C/C++ basics + OOP fundamentals
Goal: Comfortable with core arithmetic and basic C++ syntax including loops and functions.
Profit-loss, time-work, speed-distance, series & coding-decoding
- 1 hr Quant (profit-loss, time-work, speed-distance)
- 45 min Logical (series, coding-decoding)
- 1 hr coding: arrays & strings easy problems
Goal: Solve 80%+ of GFG Easy array/string problems and quant PYQs within time.
Puzzles, arrangements, RC, arrays, strings, sorting & hashing
- 45 min puzzles & seating arrangements
- 30 min RC practice
- 1.5 hr coding: sorting, searching, hashing
Goal: Solve seating-arrangement puzzles under 5 minutes and hashing problems confidently.
Linked lists, stacks, queues, recursion, binary search, two pointers
- 1.5 hr coding: linked lists, stacks/queues, recursion
- 30 min essay writing practice (1 essay/day)
Goal: Reverse a linked list, detect cycles, and write a clean 20-minute essay.
Trees, graphs, greedy, DP and two timed coding problems
- 1 problem on trees/graphs (BFS/DFS)
- 1 DP problem
- One full 60-minute 2-problem coding mock
Goal: Solve one medium DP/graph problem daily within 25–30 minutes.
Full mocks, essays, technical MCQs, interview & project revision
- One full 128-minute simulation (aptitude + essay + coding)
- Revise OOP, DBMS, OS theory
- Mock technical + HR interview
Goal: Complete two full timed simulations and explain your project fluently.
Exam Day Strategy
Score targets and time allocation.
Section targets
- Quantitative Ability: Aim 10+/16 in ~15 min; skip lengthy DI sets on first pass.
- Logical Reasoning: Aim 10+/14 in ~13 min; solve series and coding-decoding first.
- Verbal Ability: Aim 15+/20 in ~18 min; answer RC direct questions first.
- Essay: Plan for 2 minutes, write for 16 minutes, review for 2 minutes.
- Coding: Solve the easier problem first (~25 min); leave 5 minutes for edge-case testing.
Coding time split (50 min)
- Read both problems — ~3 min
- Solve the easier problem first — ~25 min
- Second problem — ~28 min
- Edge cases and re-runs — ~4 min
Interview Process
What follows the online test.
Technical Interview — Project Engineer
- • C/C++/Java fundamentals, arrays and strings, basic DSA
- • OOP: inheritance, polymorphism, encapsulation with examples
- • DBMS and SQL basics; OS basics (process vs thread, deadlock)
- • Networking basics; explain your project and basic debugging
Technical Interview — Turbo / Junior Associate SE
- • Medium-level DSA: recursion, backtracking, trees, graphs, DP
- • SQL joins, grouping and subqueries; transactions and normalization
- • Processes, threads and deadlocks; HTTP, DNS and TCP/IP
- • Git and project architecture discussion
HR Interview — all roles
- • Tell me about yourself; why Wipro?
- • Explain your project's architecture and individual contribution
- • Are you comfortable relocating or working in shifts?
- • Strengths, weaknesses and career goals
Mock Test Plan
Four simulations to run before the real test.
Mock 1 — Full Aptitude Block
- • 16 Quant + 14 Logical + 18 Verbal in 48 minutes
- • Target 70%+ overall with no section left blank
Mock 2 — Essay Sprint
- • Write 3 essays on different topics, 20 minutes each
- • Review for grammar, coherence and structure
Mock 3 — Coding Round
- • 2 problems in 60 minutes at Turbo-level difficulty
- • Test with empty, single-element and duplicate inputs
Mock 4 — Full Simulation
- • Aptitude + Essay + Coding in one 128-minute session
- • Use a strict timer; no breaks during sections
Mock 5 — Interview Simulation
- • 20 min technical (OOP, SQL, OS, DSA)
- • 10 min HR covering relocation, shifts and project story
Final Checklist
Tick all of these before test day.
Recent Interview Experiences
First-hand write-ups from students who actually sat the Wipro process.
Be the first to share a Wipro interview experience.
Frequently Asked Questions
What is the Wipro Elite NLTH exam pattern in 2026?
A non-adaptive online assessment with roughly 48 minutes of combined Quant, Logical and Verbal aptitude, a 20-minute written communication essay and a 60-minute coding round with 2 problems — about 128 minutes total, followed by technical and HR interviews.
What is the difference between Elite NLTH and Turbo?
Elite NLTH hires for Project Engineer with an easier coding bar, while Turbo (Junior Associate SE) expects stronger coding, a tougher technical interview and sometimes an additional business discussion or voice assessment round.
How is the essay in the Wipro test scored?
It evaluates grammar, coherence, vocabulary, organisation and the ability to express an opinion with supporting arguments. Aim for a 4-paragraph, 200–300 word structure on a tech or social topic.
Which languages are allowed in the Wipro coding round?
C, C++, Java and Python are commonly supported across Elite NLTH and Turbo drives.
Should I prepare for Elite NLTH or Turbo-level coding?
Prepare for Turbo-level coding since it also covers Project Engineer requirements — prioritise aptitude speed, coding accuracy, essay writing and clear communication, since Wipro's recent formats evaluate all four rather than coding alone.
Is there negative marking in the Wipro aptitude section?
Most recent drives report no strict negative marking, but always confirm instructions on your specific test screen since formats vary by drive and location.
Want the full structured prep for Wipro?
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 Wipro 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