CrackIT

Free IT Interview Prep Platform

Crack Your

Structured interview prep for software testers. Real questions from TCS, Infosys, Wipro, Amazon and more. 100% free.

Asked at:TCSInfosysWiproAmazonSwiggyZomato

500+~~Questions~~

8~~Topics~~

23~~SQL Modules~~

3~~Levels~~

Free~~Always~~

TOPICS

What are you preparing for?

Click any topic for structured interview prep — fresher to senior level.

📋

Manual Testing

SDLC, STLC, bug lifecycle, test cases, UAT — 32 Q&A + study guide + revision

32 Q&AStudy GuideRevision

🤖

Selenium

XPath, locators, POM, TestNG, WebDriver — real scenario-based questions

FresherMidSenior

🔗

API Testing

REST, SOAP, Postman, HTTP methods, status codes, authentication

RESTPostmanFresherSenior

☕

Core Java

OOPs, collections, exceptions, strings, arrays — Java for testers

OOPsCollections6 Sections

🗃

SQL

DDL, DML, JOINs, subqueries, indexes — interview Q&A + 23 learn modules

23 ModulesZero to Advanced

⚙

DevOps

Git, Docker, Jenkins, CI/CD, Linux — for testers moving into DevOps roles

DockerJenkins11 sections

💻

Java ProgramsLogic, sorting, patterns explained

→

🧪

Practice QuizTest yourself across all topics

→

📄

Resume BuilderBuild your IT resume free

→

ROADMAP

Manual → Automation Engineer Path

A clear step-by-step path — from zero to job-ready Automation Engineer.

Phase 1 · 0–3 Months

Manual Testing Foundation

SDLC & STLCBug LifecycleTest CasesRegression TestingBasic SQL

Phase 2 · 3–5 Months

Core Java for Testers

OOPsCollectionsExceptionsPrograms

Phase 3 · 5–8 Months

Selenium Automation

WebDriverXPathPOMTestNG

Phase 4 · 8–12 Months

API Testing + CI/CD

PostmanRestAssuredJenkinsGit

🎉 Goal

Job-Ready Automation Engineer

₹6–15 LPATCS / AmazonInterview Ready ✓

Most Asked Interview Questions

Manual Testing

Top Manual Testing Interview Q&A

SDLC, STLC, bug lifecycle — fresher to senior

Read →

Selenium

Selenium WebDriver Interview Questions 2026

XPath, locators, POM, TestNG — real scenarios

Read →

API Testing

API Testing — REST, Postman, RestAssured

HTTP methods, status codes, auth, collections

Read →

SQL

SQL Interview Q&A + Learn SQL (23 Modules)

DDL, DML, JOINs, subqueries — zero to advanced

Read →

Core Java

Core Java for Testers — OOPs to Collections

6 structured sections — everything a tester needs

Read →

DevOps

DevOps Interview Q&A for QA Engineers

Docker, Jenkins, Kubernetes, AWS — 11 sections

Read →

Experience:

🗃️ SQL Interview Questions

Fresher Level · Asked in TCS, Infosys, Wipro, Amazon, Swiggy, Zomato

Q1What is SQL? What is the difference between SQL and MySQL?▾

SQL (Structured Query Language) is the standard language used to communicate with relational databases. It is used to create, read, update and delete data.

MySQL is a Database Management System (DBMS) — software that uses SQL. Think of SQL as the language, MySQL as an application that speaks it. Others: Oracle, PostgreSQL, SQL Server.

Always say: SQL is a language, MySQL is a software. This basic distinction impresses interviewers!

CONCEPTIMPORTANTTCSInfosysWipro

Q2What are DDL, DML, DCL and TCL commands? Give examples.▾

DDL (Data Definition Language) — defines structure:
Commands: CREATE, ALTER, DROP, TRUNCATE, RENAME

DML (Data Manipulation Language) — manipulates data:
Commands: SELECT, INSERT, UPDATE, DELETE

DCL (Data Control Language) — controls access:
Commands: GRANT, REVOKE

TCL (Transaction Control Language) — controls transactions:
Commands: COMMIT, ROLLBACK, SAVEPOINT

Is SELECT a DML command? YES! Many candidates forget SELECT is DML.

CONCEPTIMPORTANTTCSWipro

Q3What is the difference between WHERE and HAVING?▾

WHERE filters rows BEFORE grouping. Works on individual rows.
HAVING filters groups AFTER GROUP BY clause.

Most freshers say both are same — this is wrong and kills your interview!

-- WHERE: filter before grouping SELECT city, COUNT(*) FROM orders WHERE status = 'delivered' GROUP BY city; -- HAVING: filter after grouping SELECT city, COUNT(*) FROM orders GROUP BY city HAVING COUNT(*) > 100;

TRAPIMPORTANTAmazonSwiggy

Q4What is the difference between DELETE, TRUNCATE and DROP?▾

DELETE: Removes specific rows. Can use WHERE. Can be rolled back. Slower.
TRUNCATE: Removes ALL rows. No WHERE clause. Faster. Cannot be rolled back in MySQL.
DROP: Deletes entire table including structure. Permanent!

Can TRUNCATE be rolled back? In MySQL NO. In PostgreSQL YES within a transaction!

DELETE FROM orders WHERE status='cancelled'; TRUNCATE TABLE orders; DROP TABLE orders;

TRAPIMPORTANTTCSWipro

Q5What are the different types of JOINs in SQL?▾

INNER JOIN: Returns only matching rows from both tables.
LEFT JOIN: All rows from left + matching from right. NULL if no match.
RIGHT JOIN: All rows from right + matching from left. NULL if no match.
FULL OUTER JOIN: All rows from both tables.
CROSS JOIN: Every row of A × every row of B (cartesian product).
SELF JOIN: Table joined with itself.

-- Find all customers even with no orders SELECT c.name, o.order_id FROM customers c LEFT JOIN orders o ON c.id = o.customer_id;

Find customers who NEVER ordered: LEFT JOIN + WHERE o.order_id IS NULL!

CONCEPTIMPORTANTTCSZomatoAmazon

Q6What is Primary Key vs Foreign Key vs Unique Key?▾

Primary Key: Uniquely identifies each row. Cannot be NULL. Only ONE per table.
Foreign Key: References Primary Key of another table. Maintains referential integrity.
Unique Key: Ensures all values unique. CAN be NULL (once). Multiple allowed per table.

PK cannot be NULL, Unique Key CAN be NULL — very common trick question!

CONCEPTIMPORTANTTCSInfosys

Q7Write a query to find the second highest salary.▾

Most asked SQL question in every IT company!

-- Method 1: Subquery SELECT MAX(salary) FROM employees WHERE salary < (SELECT MAX(salary) FROM employees); -- Method 2: LIMIT OFFSET (MySQL) SELECT salary FROM employees ORDER BY salary DESC LIMIT 1 OFFSET 1; -- Method 3: DENSE_RANK() -- BEST! SELECT salary FROM ( SELECT salary, DENSE_RANK() OVER (ORDER BY salary DESC) AS rnk FROM employees ) t WHERE rnk = 2;

Always mention all 3 methods! Method 3 with DENSE_RANK() impresses senior interviewers most.

TRAPIMPORTANTAmazonTCSSwiggy

Q8What is Normalization? Explain 1NF, 2NF, 3NF.▾

Normalization: Organizing database to reduce data redundancy and improve integrity.

1NF: Each cell has single value. No repeating groups.
❌ phone = '9999,8888' → ✅ separate rows per phone

2NF: Must be 1NF + no partial dependency (every non-key column depends on WHOLE PK).

3NF: Must be 2NF + no transitive dependency.
❌ emp_id → dept_id → dept_name
✅ dept_name in separate Departments table

Simple rule: 1NF=atomic values, 2NF=full PK dependency, 3NF=no column depends on another non-key column.

CONCEPTIMPORTANTTCSInfosys

Q9What is a View in SQL? When would you use it?▾

View: A virtual table based on a SQL query. Does NOT store data physically — it's a saved query.

✅ Security: Expose only certain columns to users
✅ Simplicity: Complex queries saved as simple view
✅ Consistency: Same logic reused across queries

CREATE VIEW emp_public AS SELECT emp_id, name, department FROM employees; -- Use like a table SELECT * FROM emp_public;

Views do NOT store data! For performance, use Materialized Views (PostgreSQL) which DO store data.

CONCEPTTCSAmazon

Q10What is an Index in SQL? What are its types?▾

Index: A data structure that speeds up data retrieval. Like a book index — jump directly instead of reading every page.

Clustered Index: Data physically sorted by this index. Only ONE per table. PK creates this by default.
Non-Clustered Index: Separate structure pointing to data. Multiple allowed.
Composite Index: Index on multiple columns.

Indexes speed up SELECT but SLOW DOWN INSERT/UPDATE/DELETE because index also gets updated! Over-indexing is a real performance problem.

CONCEPTIMPORTANTAmazonSwiggy

Mid Level · Asked in Amazon, Swiggy, Zomato, TCS

Q1Explain Window Functions. When to use them vs GROUP BY?▾

Window Functions perform calculations across rows WITHOUT collapsing them (unlike GROUP BY).

Key functions: RANK(), DENSE_RANK(), ROW_NUMBER(), LAG(), LEAD(), SUM() OVER(), AVG() OVER()

-- Rank orders per customer by amount SELECT customer_id, order_amount, RANK() OVER(PARTITION BY customer_id ORDER BY order_amount DESC) AS rank_num FROM orders; -- Running total (impossible with GROUP BY!) SELECT date, sales, SUM(sales) OVER(ORDER BY date) AS running_total FROM daily_sales;

GROUP BY reduces rows. Window functions KEEP all rows but add a computed column.

CONCEPTIMPORTANTAmazonSwiggy

Q2What is the difference between RANK(), DENSE_RANK() and ROW_NUMBER()?▾

ROW_NUMBER(): Unique sequential numbers regardless of ties → (1,2,3,4)
RANK(): Same rank for ties, SKIPS next number → (1,1,3,4)
DENSE_RANK(): Same rank for ties, does NOT skip → (1,1,2,3)

-- Salaries: 100, 100, 90, 80 -- ROW_NUMBER : 1, 2, 3, 4 -- RANK : 1, 1, 3, 4 (skips 2!) -- DENSE_RANK : 1, 1, 2, 3 (no skip)

For "nth highest salary" always use DENSE_RANK — RANK can skip numbers and miss results!

TRAPIMPORTANTAmazonSwiggy

Q3What is LAG() and LEAD()? Give a real example.▾

LAG(): Access value from PREVIOUS row.
LEAD(): Access value from NEXT row.

-- Compare today's orders vs yesterday SELECT order_date, total_orders, LAG(total_orders, 1) OVER (ORDER BY order_date) AS prev_day, total_orders - LAG(total_orders,1) OVER (ORDER BY order_date) AS difference FROM daily_orders; -- Output: -- 2026-01-01 | 500 | NULL | NULL -- 2026-01-02 | 620 | 500 | +120 -- 2026-01-03 | 580 | 620 | -40

CONCEPTIMPORTANTSwiggyZomato

Q4Write a query to find employees who earn more than their manager.▾

Classic SELF JOIN question asked in almost every product company!

-- employees: emp_id, name, salary, manager_id SELECT e.name AS employee, e.salary AS emp_salary, m.name AS manager, m.salary AS mgr_salary FROM employees e JOIN employees m ON e.manager_id = m.emp_id WHERE e.salary > m.salary;

This is a SELF JOIN — same table joined with itself using alias. Very common for hierarchy data!

IMPORTANTAmazonTCS

Q5What is a CTE? How is it different from a Subquery?▾

Subquery: Query nested inside another query. One-time use.
CTE (Common Table Expression): Named temporary result using WITH keyword. Reusable, more readable.

-- Subquery approach SELECT * FROM employees WHERE salary > (SELECT AVG(salary) FROM employees); -- CTE approach (cleaner!) WITH avg_sal AS ( SELECT AVG(salary) AS avg_salary FROM employees ) SELECT e.* FROM employees e, avg_sal WHERE e.salary > avg_sal.avg_salary;

CTEs are better for readability, debugging, and when referencing the result multiple times!

CONCEPTIMPORTANTAmazonSwiggy

Q6Write a query to find duplicate records in a table.▾

-- Find duplicate emails SELECT email, COUNT(*) AS cnt FROM users GROUP BY email HAVING COUNT(*) > 1; -- Delete duplicates, keep one DELETE FROM users WHERE id NOT IN ( SELECT MIN(id) FROM users GROUP BY email );

IMPORTANTTCSWipro

Q7What is the difference between UNION and UNION ALL?▾

UNION: Combines results and REMOVES duplicates. Slower.
UNION ALL: Combines results and KEEPS duplicates. Faster.

Both SELECT statements must have same number of columns and compatible data types!

CONCEPTTRAPTCS

Q8How do you optimize a slow SQL query?▾

Step 1 → EXPLAIN/EXPLAIN ANALYZE: See the execution plan. Look for full table scans (type=ALL is bad).

Step 2 → Check Indexes: Are WHERE/JOIN/ORDER BY columns indexed?

Step 3 → Rewrite Query:
• Avoid SELECT *
• Avoid functions on indexed columns in WHERE
• Use EXISTS instead of IN for large subqueries

Step 4 → Partitioning: For huge tables (100M+ rows)

Step 5 → Caching: Redis/Memcached for frequent reads

Always start with EXPLAIN! Never guess. Let the execution plan tell you what's wrong.

IMPORTANTAmazonSwiggy

Senior Level · Asked in Amazon, Swiggy, Zomato

Q1Explain ACID properties with real examples.▾

A - Atomicity: All or nothing. Bank transfer: debit+credit happen together or not at all.
C - Consistency: DB goes from one valid state to another. Balance cannot go negative.
I - Isolation: Concurrent transactions don't interfere with each other.
D - Durability: Committed data survives crashes.

BEGIN; UPDATE accounts SET balance = balance - 1000 WHERE id=1; UPDATE accounts SET balance = balance + 1000 WHERE id=2; COMMIT;

CONCEPTIMPORTANTAmazonSwiggy

Q2Design a database schema for a food delivery app like Swiggy.▾

users(user_id PK, name, email, phone, created_at) restaurants(rest_id PK, name, city, rating, is_active) menu_items(item_id PK, rest_id FK, name, price, category, is_veg) orders(order_id PK, user_id FK, rest_id FK, total, status, delivery_address, created_at) order_items(id PK, order_id FK, item_id FK, qty, price_at_order) delivery(del_id PK, order_id FK, partner_id FK, status, location) reviews(id PK, user_id FK, rest_id FK, rating, comment)

Always mention price_at_order — captures price at time of purchase. Menu prices can change later!

IMPORTANTSwiggyZomato

☕ Basic Java

What is Java · JDK / JRE / JVM · How Java Works · Core Concepts

1What is Java? Why is it platform independent?▾

Java is a high-level, object-oriented programming language developed by Sun Microsystems (now Oracle) in 1995.

Platform Independence: Java code is compiled into bytecode (.class file) by the Java Compiler. This bytecode runs on any machine that has a JVM (Java Virtual Machine) installed — regardless of OS.

Write Once, Run Anywhere (WORA) is Java's key principle.

2What is JDK, JRE, and JVM? What is the difference?▾

JVM (Java Virtual Machine) — Executes bytecode. Platform-specific. Core of Java's WORA.

JRE (Java Runtime Environment) — JVM + libraries needed to RUN Java programs. For end users.

JDK (Java Development Kit) — JRE + compiler (javac) + tools needed to DEVELOP Java programs. For developers.

JDK ⊃ JRE ⊃ JVM

3How does Java code execute? Explain the flow.▾

1. Write .java source file
2. javac compiler compiles it to .class (bytecode)
3. JVM loads the .class file via ClassLoader
4. Bytecode Verifier checks the code
5. Interpreter / JIT Compiler converts bytecode to machine code and executes

Source (.java) → Bytecode (.class) → JVM → Machine Code → Output

4What are the main features of Java?▾

• Object-Oriented — Everything is an object
• Platform Independent — WORA via JVM
• Simple — No pointers, easy syntax
• Secure — No explicit pointer, bytecode verification
• Robust — Strong memory management, exception handling
• Multithreaded — Supports concurrent execution
• High Performance — JIT compiler optimizes at runtime
• Distributed — Supports RMI, JDBC for network apps

●What are variables? What are the types in Java?▾

A variable is a named memory location to store data.

Types:
• Local Variable — declared inside a method, no default value
• Instance Variable — declared inside class but outside method, has default value
• Static Variable — declared with static keyword, shared across all objects

●What are the 8 primitive data types in Java?▾

Type	Size	Range	Default
byte	1 byte	-128 to 127	0
short	2 bytes	-32768 to 32767	0
int	4 bytes	-2^31 to 2^31-1	0
long	8 bytes	-2^63 to 2^63-1	0L
float	4 bytes	~3.4e38	0.0f
double	8 bytes	~1.8e308	0.0d
char	2 bytes	0 to 65535 (Unicode)	'\u0000'
boolean	1 bit	true / false	false

●What is type casting? Implicit vs Explicit?▾

Implicit (Widening) — automatic, no data loss: int → long → float → double
int a = 10; double d = a; // OK automatically

Explicit (Narrowing) — manual, may lose data:
double d = 9.99; int a = (int) d; // a = 9, decimal lost

💾 Arrays

1What is an Array?▾

An array is a data structure used to store multiple values of the same data type in a single variable.
Each value is stored at a continuous memory location and accessed using an index (starting from 0).

int[] arr = {10, 20, 30};

2Why do we need Arrays?▾

● Store multiple values of the same type

● Avoid declaring many variables

● Easy access using index

● Faster performance due to continuous memory

● Used when number of elements is fixed

3How do you declare an Array in Java?▾

1️⃣ Declaration only

int[] arr;

2️⃣ Declaration + Creation

int[] arr = new int[5];

3️⃣ Declaration + Initialization

int[] arr = {1, 2, 3, 4};

4Default values of Array for different data types▾

Data Type	Default Value
int	0
float	0.0
double	0.0
char	''
boolean	false
String / Object	null

5Can you change the size of an Array after creation?▾

❌ No. Array size is fixed once created.

👉 If dynamic size is needed → use ArrayList

6Can you pass a negative number in Array size?▾

❌ No.

int[] arr = new int[-5]; // Runtime error

Throws: NegativeArraySizeException

7Can you declare an Array without size?▾

✔ Yes, but only with initialization

int[] arr = {1, 2, 3}; // ✔ Allowed

❌ Not allowed:

int[] arr;
arr = {1,2,3}; // ❌ Compile-time error

8Where is Array stored in JVM memory?▾

● Array object → stored in Heap memory

● Array reference variable → stored in Stack memory

9Where is a primitive Array stored in JVM?▾

● Primitive array object → Heap

● Primitive values → inside heap array object

10What is ArrayStoreException?▾

Thrown when you store wrong data type into an array of objects.

Object[] arr = new Integer[5];
arr[0] = "Hello"; // Runtime Exception

Throws: ArrayStoreException

11ArrayStoreException vs ArrayIndexOutOfBoundsException▾

	ArrayStoreException	ArrayIndexOutOfBoundsException
Cause	Wrong data type stored	Invalid index used
Type	Runtime exception	Runtime exception
Error	Type mismatch	Index range error

12Advantages of Array▾

✔ Fast access using index

✔ Simple structure

✔ Memory efficient (continuous memory)

✔ Supports primitive types

13Disadvantages of Array▾

❌ Fixed size — cannot grow or shrink

❌ Insertion and deletion are costly O(n)

❌ No built-in methods like collections

14Can we use Generics with Array?▾

❌ No. Generic arrays are not allowed in Java.

List[] arr; // Not allowed

👉 Use Collections instead

15What is an Anonymous Array?▾

Array created without a reference variable and used only once.

sum(new int[]{10, 20, 30});

static void sum(int[] arr) {
    int total = 0;
    for (int i : arr) total += i;
    System.out.println(total); // 60
}

16Difference between Array and ArrayList▾

	Array	ArrayList
Size	Fixed	Dynamic
Speed	Faster	Slightly slower
Types	Primitives + Objects	Objects only
Methods	No built-in methods	Rich API (add, remove...)

17Difference between Array and LinkedList▾

	Array	LinkedList
Memory	Continuous	Non-continuous
Access	Fast O(1)	Slow O(n)
Size	Fixed	Dynamic
Memory usage	Less	More (stores pointers too)

18What are Jagged Arrays?▾

Arrays where each row can have a different number of columns.

int[][] arr = {
    {1, 2},
    {3, 4, 5},
    {6}
};

19Ways to copy one Array to another▾

● Using loop

● System.arraycopy()

● Arrays.copyOf()

● clone()

int[] copy = arr.clone();

20What happens if you don't initialize an Array?▾

● Reference variable → null

● Accessing it → NullPointerException

"Always initialize your array before accessing it to avoid NullPointerException."

P1Find the largest element in an array [TCS, Infosys, Wipro]▾

🆕 Approach 1 — Manual loop (without built-in)

// Assume first element is largest, compare with rest
int[] arr = {3, 1, 9, 2, 7};
int max = arr[0];               // step 1: assume arr[0] is max
for(int i = 1; i < arr.length; i++){  // step 2: loop from index 1
  if(arr[i] > max){            // step 3: if current > max
    max = arr[i];               // step 4: update max
  }
}
System.out.println("Largest: " + max); // Output: 9

⚡ Approach 2 — Using Arrays.sort() (built-in)

import java.util.Arrays;
int[] arr = {3, 1, 9, 2, 7};
Arrays.sort(arr);                          // sort ascending
System.out.println("Largest: " + arr[arr.length - 1]); // last = largest

📊 Approach 3 — Using Collections (for ArrayList)

import java.util.Collections;
import java.util.Arrays;
Integer[] arr = {3, 1, 9, 2, 7};
System.out.println("Largest: " + Collections.max(Arrays.asList(arr)));

P2Reverse an array [Amazon, Wipro, Cognizant]▾

🆕 Approach 1 — Two pointer (without built-in)

int[] arr = {1, 2, 3, 4, 5};
int left = 0, right = arr.length - 1;
while(left < right){          // step 1: loop until pointers meet
  int temp = arr[left];        // step 2: save left value
  arr[left] = arr[right];      // step 3: put right into left
  arr[right] = temp;           // step 4: put saved into right
  left++;                      // step 5: move pointers inward
  right--;
}
// Output: {5, 4, 3, 2, 1}

⚡ Approach 2 — Using Collections.reverse()

import java.util.*;
Integer[] arr = {1, 2, 3, 4, 5};
List list = Arrays.asList(arr);
Collections.reverse(list);
System.out.println(Arrays.toString(arr)); // [5, 4, 3, 2, 1]

📊 Approach 3 — New array

int[] arr = {1, 2, 3, 4, 5};
int[] rev = new int[arr.length];
for(int i = 0; i < arr.length; i++){
  rev[i] = arr[arr.length - 1 - i]; // fill from end
}
System.out.println(Arrays.toString(rev)); // [5, 4, 3, 2, 1]

P3Find duplicate elements in an array [TCS, Accenture, Amazon]▾

🆕 Approach 1 — Nested loops O(n²)

int[] arr = {1, 2, 3, 2, 4, 3, 5};
for(int i = 0; i < arr.length; i++){
  for(int j = i + 1; j < arr.length; j++){
    if(arr[i] == arr[j]){            // compare each pair
      System.out.println("Duplicate: " + arr[i]);
    }
  }
}

⚡ Approach 2 — Using HashSet O(n) [BEST]

import java.util.HashSet;
int[] arr = {1, 2, 3, 2, 4, 3, 5};
HashSet seen = new HashSet<>();
for(int num : arr){
  if(!seen.add(num)){     // add() returns false if already exists
    System.out.println("Duplicate: " + num);
  }
}

📊 Approach 3 — Sort then compare adjacent

int[] arr = {1, 2, 3, 2, 4, 3, 5};
Arrays.sort(arr); // {1, 2, 2, 3, 3, 4, 5}
for(int i = 0; i < arr.length - 1; i++){
  if(arr[i] == arr[i+1]){  // adjacent same = duplicate
    System.out.println("Duplicate: " + arr[i]);
  }
}

P4Find second largest element [Infosys, Wipro, TCS]▾

🆕 Approach 1 — Single loop O(n) [BEST]

int[] arr = {10, 5, 8, 20, 15};
int first = Integer.MIN_VALUE;   // track largest
int second = Integer.MIN_VALUE;  // track second largest
for(int num : arr){
  if(num > first){          // new largest found
    second = first;           // old largest becomes second
    first = num;
  } else if(num > second && num != first){ // new second
    second = num;
  }
}
System.out.println("Second largest: " + second); // 15

⚡ Approach 2 — Sort and pick

int[] arr = {10, 5, 8, 20, 15};
Arrays.sort(arr); // {5, 8, 10, 15, 20}
System.out.println("Second largest: " + arr[arr.length - 2]); // 15

P5Rotate array by K positions [Amazon, Google]▾

🆕 Approach 1 — Extra array

int[] arr = {1, 2, 3, 4, 5};
int k = 2; // rotate right by 2
int n = arr.length;
int[] result = new int[n];
for(int i = 0; i < n; i++){
  result[(i + k) % n] = arr[i]; // place at shifted position
}
System.out.println(Arrays.toString(result)); // [4, 5, 1, 2, 3]

⚡ Approach 2 — Reverse method O(n) O(1) space [OPTIMAL]

// Rotate right by k: reverse all, reverse first k, reverse rest
void rotate(int[] arr, int k){
  k = k % arr.length;
  reverse(arr, 0, arr.length-1); // reverse whole array
  reverse(arr, 0, k-1);          // reverse first k
  reverse(arr, k, arr.length-1); // reverse rest
}
void reverse(int[] arr, int l, int r){
  while(l < r){ int t=arr[l]; arr[l]=arr[r]; arr[r]=t; l++; r--; }
}

🔠 Strings

1What is String?▾

A String is a sequence of characters in Java.

Example

String name = "Akshay";

Important Points

● String is a class in Java

● It is immutable

● Stored in String Constant Pool

2Why String is Immutable?▾

Immutable means value cannot be changed after creation.

Example

String s = "Welcome";
s.concat(" Java");
System.out.println(s);

Output

Welcome

Reason: concat() creates a new object, original object is not changed.

Advantages

● Security

● Thread safety

● Memory optimization (String Pool)

3String Declaration (2 Ways)▾

1️⃣ String Literal

String s1 = "Java";

● Stored in String Constant Pool

2️⃣ new Keyword

String s2 = new String("Java");

● Stored in Heap memory

4Important String Methods▾

1️⃣ length()

Returns number of characters.

String s = "Java";
System.out.println(s.length());

Output

2️⃣ contains()

Checks if substring exists.

String s = "Welcome to Java";
s.contains("Java");

Output

true

3️⃣ trim()

Removes leading and trailing spaces.

String s = "  Java  ";
System.out.println(s.trim());

Output

Java

4️⃣ replace()

Replaces characters or words.

String s = "Java";
System.out.println(s.replace("a","o"));

Output

Jovo

5️⃣ concat()

Joins two strings.

String s1 = "Core";
String s2 = "Java";
System.out.println(s1.concat(s2));

Output

CoreJava

6️⃣ equals()

Compares string values.

String a = "Java";
String b = "Java";
a.equals(b);

Output

true

7️⃣ equalsIgnoreCase()

Ignores case while comparing.

"JAVA".equalsIgnoreCase("java");

Output

true

8️⃣ substring()

Extracts part of string.

String s = "Automation";
System.out.println(s.substring(0,4));

Output

Auto

9️⃣ toLowerCase() / toUpperCase()

String s = "Java";
s.toUpperCase();  // JAVA
s.toLowerCase();  // java

🔀 split()

Splits string using delimiter.

String s = "Java,Python,SQL";
String[] arr = s.split(",");

Output

Java Python SQL

5String Comparison — == vs equals()▾

Operator	Compares
==	Memory address
equals()	Value

Example

String s1 = new String("Java");
String s2 = new String("Java");

System.out.println(s1 == s2);      // false
System.out.println(s1.equals(s2)); // true

6Mutable vs Immutable — String, StringBuffer, StringBuilder▾

Type	Mutable	Thread Safe
String	❌	✔
StringBuffer	✔	✔
StringBuilder	✔	❌

StringBuffer Example

StringBuffer sb = new StringBuffer("Welcome");
sb.append(" Java");
System.out.println(sb);

Output

Welcome Java

StringBuilder Example

StringBuilder sb = new StringBuilder("Welcome");
sb.append(" Java");

● Used when performance is important

7WHY String is Immutable — Deep Dive 🔥▾

1️⃣ Security

Strings are used for: passwords, database URLs, file paths

If String were mutable, anyone could change values, causing security issues.

2️⃣ String Constant Pool (Memory Optimization)

String s1 = "Java";
String s2 = "Java";

● Both refer to same object

● Immutability makes this safe

3️⃣ Thread Safety

● Immutable objects are automatically thread-safe

● No synchronization required

8Why StringBuilder is Mutable + Interview Answer 🔥▾

"StringBuilder is mutable to improve performance when frequent modifications are required, such as loops, dynamic data, or string construction."

Example

StringBuilder sb = new StringBuilder("Akshay");
sb.replace(0, 6, "Rahul");
System.out.println(sb);

✔ Same object — no new object creation

✔ Faster execution

🔥 Interview Power Line 💪
"We use String when data should not change, and StringBuilder when data changes frequently for better performance."

🆕 Interview-Ready Answer (USE THIS)

"String is immutable in Java, which means once a String object is created, its value cannot be changed.
Any modification like concat or replace creates a new object.
Java made String immutable mainly for security, thread safety, and memory optimization using the String Constant Pool.
StringBuilder is mutable, which means its value can be modified without creating new objects.
It is mainly used when we have frequent string modifications because it gives better performance."

P1Check if a String is Palindrome [TCS, Infosys, Wipro, Amazon]▾

🆕 Approach 1 — Two pointer (without built-in)

String s = "racecar";
int left = 0, right = s.length() - 1;
boolean isPalin = true;
while(left < right){
  if(s.charAt(left) != s.charAt(right)){ // chars don't match
    isPalin = false;
    break;
  }
  left++;   // move inward
  right--;
}
System.out.println(isPalin ? "Palindrome" : "Not Palindrome");

⚡ Approach 2 — Using StringBuilder.reverse()

String s = "racecar";
String rev = new StringBuilder(s).reverse().toString();
System.out.println(s.equals(rev) ? "Palindrome" : "Not Palindrome");

📊 Approach 3 — Using toCharArray()

String s = "racecar";
char[] ch = s.toCharArray();
boolean flag = true;
for(int i = 0; i < ch.length / 2; i++){
  if(ch[i] != ch[ch.length - 1 - i]){ flag = false; break; }
}
System.out.println(flag ? "Palindrome" : "Not Palindrome");

P2Reverse a String [TCS, Wipro, Cognizant, Amazon]▾

🆕 Approach 1 — Loop without built-in

String s = "Hello";
String rev = "";
for(int i = s.length() - 1; i >= 0; i--){ // loop from end
  rev += s.charAt(i);  // append each char in reverse
}
System.out.println(rev); // "olleH"

⚡ Approach 2 — StringBuilder.reverse() [SIMPLEST]

String s = "Hello";
String rev = new StringBuilder(s).reverse().toString();
System.out.println(rev); // "olleH"

📊 Approach 3 — Using char array

String s = "Hello";
char[] ch = s.toCharArray();
int l = 0, r = ch.length - 1;
while(l < r){ char t = ch[l]; ch[l] = ch[r]; ch[r] = t; l++; r--; }
System.out.println(new String(ch)); // "olleH"

P3Count vowels and consonants in a String [Infosys, Accenture]▾

🆕 Approach 1 — Loop with condition

String s = "Hello World";
int vowels = 0, consonants = 0;
s = s.toLowerCase(); // normalize case
for(int i = 0; i < s.length(); i++){
  char c = s.charAt(i);
  if(c == 'a'||c == 'e'||c == 'i'||c == 'o'||c == 'u'){
    vowels++;       // it's a vowel
  } else if(c >= 'a' && c <= 'z'){
    consonants++;   // it's a letter but not vowel
  }
}
System.out.println("Vowels: " + vowels + ", Consonants: " + consonants);

⚡ Approach 2 — Using regex (built-in)

String s = "Hello World";
int vowels = s.replaceAll("[^aeiouAEIOU]", "").length();
int consonants = s.replaceAll("[^a-zA-Z]","").length() - vowels;
System.out.println("Vowels: " + vowels + ", Consonants: " + consonants);

P4Check if two strings are Anagram [Amazon, TCS, Wipro]▾

Anagram = same characters, different order. e.g. "listen" and "silent"

🆕 Approach 1 — Sort and compare

String s1 = "listen", s2 = "silent";
char[] a = s1.toCharArray();
char[] b = s2.toCharArray();
Arrays.sort(a); // sort both
Arrays.sort(b);
System.out.println(Arrays.equals(a, b) ? "Anagram" : "Not Anagram");

⚡ Approach 2 — Character count array O(n) [BEST]

String s1 = "listen", s2 = "silent";
if(s1.length() != s2.length()){
  System.out.println("Not Anagram"); return;
}
int[] count = new int[26];
for(int i = 0; i < s1.length(); i++){
  count[s1.charAt(i) - 'a']++; // increment for s1
  count[s2.charAt(i) - 'a']--; // decrement for s2
}
for(int c : count){
  if(c != 0){ System.out.println("Not Anagram"); return; }
}
System.out.println("Anagram");

P5Find first non-repeating character [Amazon, Google, Flipkart]▾

🆕 Approach 1 — Nested loop O(n²)

String s = "aabbcdeeff";
char result = '-';
for(int i = 0; i < s.length(); i++){
  boolean repeat = false;
  for(int j = 0; j < s.length(); j++){
    if(i != j && s.charAt(i) == s.charAt(j)){
      repeat = true; break;
    }
  }
  if(!repeat){ result = s.charAt(i); break; }
}
System.out.println("First non-repeat: " + result); // c

⚡ Approach 2 — LinkedHashMap O(n) [BEST]

import java.util.LinkedHashMap;
String s = "aabbcdeeff";
LinkedHashMap map = new LinkedHashMap<>();
for(char c : s.toCharArray()){
  map.put(c, map.getOrDefault(c, 0) + 1); // count frequency
}
for(char c : map.keySet()){
  if(map.get(c) == 1){  // first with count 1
    System.out.println("First non-repeat: " + c); // c
    break;
  }
}

🆕 OOPs

1What is a Class?▾

A class is a blueprint or template used to create objects. It contains variables (data members) and methods (behavior).
A class itself does not occupy memory until an object is created.

Key Points (4-year level)

● Class is a logical entity

● Class defines what an object will have

● Memory is allocated only when object is created

● One class → multiple objects

Simple Analogy (use this in interview)

🏠 Class = Blueprint of a house

🏠 Object = Actual house built using that blueprint

2What is an Object?▾

An object is an instance of a class. It represents a real-world entity and occupies memory in the heap. Objects are used to access class variables and methods.

Key Points

● Object is a physical entity

● Created using new keyword

● Occupies heap memory

● Each object has its own copy of instance variables

3Relationship Between Class & Object▾

	Class	Object
Nature	Blueprint, Logical	Real implementation, Physical
Memory	No memory	Occupies memory
Count	One per design	Many can be created

Code Example (Interview Safe)

class Car {
    String brand;
    int speed;

    void drive() {
        System.out.println("Car is driving");
    }
}

public class MainClass {
    public static void main(String[] args) {
        Car car1 = new Car();
        car1.brand = "BMW";
        car1.speed = 120;
        car1.drive();

        Car car2 = new Car();
        car2.brand = "Audi";
        car2.speed = 140;
        car2.drive();
    }
}

● Car → class

● car1, car2 → objects

● Each object has separate memory

● Methods are called using object reference

74-Year Experience Interview Traps 🚨▾

Trap 1 — Q: Does class occupy memory?

✅ No, only objects occupy memory.

Trap 2 — Q: Can we create multiple objects from one class?

✅ Yes, any number of objects can be created.

Trap 3 — Q: Why is main static?

✅ JVM calls it without creating an object.

8One-Line Interview Summary 🔥▾

🔥 Memorize This

"A class is a blueprint that defines variables and methods, while an object is an instance of that class which occupies memory and is used to access those members."

1What is a Method?▾

A method is a block of code inside a class that defines behavior of an object. It is executed when it is called.

Four Types of Methods

Type	Parameters	Return Type
1	No parameter	No return
2	No parameter	Return value
3	With parameter	No return
4	With parameter	Return value

// Type 1: No parameter, no return
void display() {
    System.out.println("Hello");
}

// Type 4: With parameter, with return
int add(int a, int b) {
    return a + b;
}

2What is a Constructor?▾

A constructor is a special method used to initialize objects. It has the same name as the class and does not have a return type.

Types of Constructor

Type	Meaning
Default constructor	No parameters
Parameterized constructor	With parameters

● If YOU do not create any constructor → Java provides a default constructor

● If you create even one constructor → Java will NOT provide default constructor automatically

3Why is a constructor needed?▾

Constructors ensure the object is initialized in a valid state at the time of creation.

4What happens if we write a constructor with return type?▾

Constructor cannot have return type, not even void.

class Car {
    void Car() {          // This is NOT a constructor
        System.out.println("Hello");
    }
}

This becomes a normal method named Car(). Because a constructor must not have any return type — if return type is present, Java treats it as a method.

🔥 Interview Upgrade Line:
"If a constructor is declared with a return type, it is treated as a normal method, not a constructor."

5Can we overload a method by changing only return type?▾

No. Method overloading cannot be done by changing only the return type. The parameter list must be different.

Why?

Java identifies methods based on: method name + parameter list

Return type is NOT part of method signature

int add(int a, int b) { return a + b; }

double add(int a, int b) { return a + b; }  // ❌ Compile error

When calling add(5, 3) — compiler cannot decide which method to call.

"Return type alone is not enough for method signature differentiation."

6If constructor has no return type, how does object get returned?▾

Car c = new Car();

What Actually Happens Internally — 4 Steps

1️⃣ Memory Allocation — new keyword allocates memory in heap

2️⃣ Constructor Execution — constructor initializes the object, sets values

3️⃣ Object Reference Creation — Java automatically returns the reference of that memory location

4️⃣ Assignment — that reference is stored in variable c

🔥 Very Important Interview Line

"The constructor initializes the object, but the new keyword allocates memory and returns the object reference."

7c2 = c1 — How many objects in heap? Garbage Collection?▾

Car c1 = new Car();   // Object 1
Car c2 = new Car();   // Object 2
c2 = c1;

Step-by-Step

Step 1: c1 created → Object 1 in heap, c1 points to Object 1

Step 2: c2 created → Object 2 in heap, c2 points to Object 2

Step 3: c2 = c1 → c2 stops pointing to Object 2, now points to Object 1

Final Memory Situation

Stack:   c1 ----> Object1
         c2 ----> Object1

Heap:    Object1  (referenced ✔)
         Object2  (no reference ❌)

🚨 Object2 is now unreferenced — it becomes eligible for Garbage Collection.
Java JVM automatically removes unused objects from heap. You do NOT delete objects manually.

8Car c = null; — Was any object created?▾

Car c = null;

❌ NO object is created. There is no new keyword. No memory allocation in heap. c is just a reference variable pointing to nothing.

🔥 Important Rule:
"Object is created ONLY when you use new ClassName(). Without new — no object."

1What is Polymorphism?▾

Polymorphism means "many forms". The same method name can behave differently in different situations.

Type	Happens At	Achieved By
Compile-Time	During compilation	Method Overloading
Runtime	During execution	Method Overriding

🎯 Interview-Ready Definition

"Polymorphism allows one interface to have multiple implementations. In Java, it is achieved using method overloading (compile-time) and method overriding (runtime)."

2Compile-Time Polymorphism — Method Overloading▾

Same method name, different parameters. Decided at compile time.

Rules

● Method name must be same

● Parameter list must be different

● Return type alone cannot change

● No inheritance needed

class Calculator {
    int add(int a, int b) {
        return a + b;
    }
    int add(int a, int b, int c) {
        return a + b + c;
    }
    double add(double a, double b) {
        return a + b;
    }
}

3Runtime Polymorphism — Method Overriding▾

A child class provides its own version of a method already defined in parent class. Decision happens at runtime.

Rules

● Same method name and parameters

● Requires inheritance

● Decision happens at runtime

class Animal {
    void sound() {
        System.out.println("Animal makes sound");
    }
}
class Dog extends Animal {
    void sound() {
        System.out.println("Dog barks");
    }
}

// Runtime Polymorphism
Animal a = new Dog();
a.sound();

Output

Dog barks

Even though reference is Animal, object is Dog. JVM decides at runtime which method to call.

4Overloading vs Overriding — Key Differences▾

	Overloading	Overriding
Where	Same class	Parent-child class
Parameters	Must differ	Must be same
Decision	Compile-time	Runtime
Inheritance	Not required	Required
Return type	Can differ	Must be same

Simple Analogy

🔨 Overloading: One person, same name, different tasks

👤 Overriding: Child replaces parent behavior

5Can we overload the main() method?▾

Yes, we can overload main() method in Java. But JVM always calls the standard main(String[] args).

class Demo {
    public static void main(String[] args) {
        System.out.println("Standard main called by JVM");
        main(10);           // manually calling overloaded
    }
    public static void main(int x) {
        System.out.println("Overloaded main: " + x);
    }
}

Standard main called by JVM Overloaded main: 10

6Can we override a static method?▾

No, static methods cannot be overridden. They can be hidden (method hiding), but NOT overridden.

Why?

● Overriding requires runtime polymorphism — decision at runtime via object

● Static methods belong to the class, not the object

● So runtime dispatch (dynamic binding) does NOT apply to static methods

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

Parent obj = new Child();
obj.show();  // Output: Parent static  (method hiding, not overriding)

"Static methods are resolved at compile time based on reference type, not runtime object type."

7Can we override a private or final method?▾

❌ private method — Cannot be overridden. Not visible to child class at all.

❌ final method — Cannot be overridden. final prevents modification.

❌ static method — Cannot be overridden (method hiding instead).

✔ public / protected — Can be overridden in child class.

"Only inherited, non-final, non-static, non-private methods can be overridden."

8What is Dynamic Method Dispatch?▾

Dynamic Method Dispatch is the mechanism by which a call to an overridden method is resolved at runtime, not compile time.

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

Shape s;
s = new Circle();     s.draw();    // Drawing Circle
s = new Rectangle();  s.draw();    // Drawing Rectangle

🔥 Interview Line

"Dynamic method dispatch is the foundation of runtime polymorphism in Java. JVM decides which overridden method to call based on the actual object type at runtime, not the reference type."

Modifier	Same Class	Same Package	Subclass	Everywhere
private	✔	❌	❌	❌
default	✔	✔	❌	❌
protected	✔	✔	✔	❌
public	✔	✔	✔	✔

1What is the this keyword?▾

this is a reference variable that refers to the current object.

Use: Differentiate instance variable and local variable

class Student {
    int marks;

    Student(int marks) {
        this.marks = marks;  // this.marks = instance variable
    }                        // marks = constructor parameter
}

● marks (left side) → instance variable

● marks (right side) → constructor parameter

● this.marks → refers to current object's variable

2What is static in Java?▾

Static members belong to the class, not to the object.

Static Variable

● Only one copy per class

● Shared among all objects

● Stored in method area (not heap)

class Employee {
    static String department = "CAC"; // shared by all employees
}

Static Method

class Demo {
    static void show() {
        System.out.println("Hello");
    }
}

Demo.show();  // called without object

3Static vs Non-Static Rules▾

Rule	Static Method	Non-Static Method
Access static variables	✔ Yes	✔ Yes
Access non-static variables	❌ No	✔ Yes
Use this keyword	❌ No	✔ Yes
Need object to call	❌ No	✔ Yes

4System.out.println() — What does each part mean?▾

● System — predefined class in java.lang

● out — static variable of type PrintStream inside System class

● println() — method of PrintStream class

5public static void main(String[] args) — Explain each word▾

● public — JVM must access it from anywhere

● static — JVM calls main without creating an object (very important)

● void — main does not return anything to JVM

● main — predefined method name, JVM looks for this exact name

● String[] args — used to receive command-line arguments

6Can we use this inside a static method?▾

No.

Why?

Concept	Belongs To
this	Object
static method	Class

Static method works without an object. If there is no object, what will this refer to? Nothing. So Java gives compile-time error.

class Demo {
    static void show() {
        System.out.println(this);  // ❌ Error
    }
}

Error: Non-static variable this cannot be referenced from a static context.

🎯 Interview-Ready Answer

"Because this refers to the current object, and static methods belong to the class and can execute without an object. Therefore, there is no current object for this to refer to."

7Why can't static method access non-static members directly?▾

🔥 Interview Upgrade Line

"Because static methods belong to the class and execute without an object, whereas non-static members belong to an instance. Without an object reference, the static method cannot determine which instance member to access."

8Difference between static and non-static?▾

🔥 Interview Ready

"Static members belong to the class and are shared among all objects, while non-static members belong to individual objects and require an object reference to access. Static members have only one copy per class, whereas non-static members have separate copies for each object."

Type	Description	Supported
Single	A extends B	✔
Multilevel	A extends B, B extends C	✔
Hierarchical	A and B both extend C	✔
Multiple	A extends B and C	❌ (via interface only)
Hybrid	Mix of above	❌ (via interface only)

Used With	Meaning
final variable	Value cannot be changed (constant)
final method	Cannot be overridden by child
final class	Cannot be extended / inherited

	Abstract Class	Interface
Methods	Abstract + concrete	All abstract (Java 7), default/static (Java 8+)
Variables	Any type	public static final only
Inheritance	extends (one only)	implements (multiple)
Constructor	Yes	No
Abstraction	0 to 100%	100%
Use when	Partial implementation shared	Full contract, multiple inheritance

	ArrayList	LinkedList	Vector
Internal	Dynamic array	Doubly linked list	Dynamic array
Access	Fast O(1)	Slow O(n)	Fast O(1)
Insert/Delete	Slow O(n)	Fast O(1)	Slow O(n)
Thread-safe	No	No	Yes
Use when	Frequent reads	Frequent add/remove	Multi-thread

	HashMap	LinkedHashMap	TreeMap
Order	No order	Insertion order	Sorted order
Null key	1 allowed	1 allowed	Not allowed
Performance	O(1)	O(1)	O(log n)
Use when	Fast lookup	Ordered insert	Sorted keys needed

💻 Java Programs — Line by Line Explained

8 Categories · Multiple Approaches · Dry Run · Beginner Friendly

1. Basic Number Operations

N1 Reverse a Number▾

// ── What does it mean? ──────────────────────────────────────────
// Input: 123  →  Output: 321
// We extract digits one by one from the END using % and build the reversed number.

// APPROACH 1: Loop using % and /  (Standard – Best for interviews)
public static int reverseNumber(int n) {
    int reversed = 0;           // will hold the final reversed number
    while (n != 0) {            // loop until all digits are processed
        int digit = n % 10;     // % gives the LAST digit   e.g. 123%10 = 3
        reversed = reversed * 10 + digit; // shift reversed left, add digit
        n = n / 10;             // remove last digit         e.g. 123/10 = 12
    }
    return reversed;
}
// DRY RUN for n = 123:
// Iteration 1: digit=3, reversed=0*10+3=3,    n=12
// Iteration 2: digit=2, reversed=3*10+2=32,   n=1
// Iteration 3: digit=1, reversed=32*10+1=321, n=0  → loop ends
// Result: 321 ✅

// APPROACH 2: Using String + StringBuilder  (Easiest – 1 line)
public static int reverseV2(int n) {
    String s = String.valueOf(Math.abs(n));           // 123 → "123"
    String rev = new StringBuilder(s).reverse().toString(); // "123" → "321"
    return Integer.parseInt(rev);                     // "321" → 321
}
// Note: Math.abs handles negative numbers

// Output:
// reverseNumber(123)  → 321
// reverseNumber(1200) → 21   (leading zeros dropped)
// reverseNumber(9)    → 9

N2 Count Digits in a Number▾

// Count how many digits are in a number.  1234 → 4 digits

// APPROACH 1: Loop dividing by 10 (Best for interviews)
public static int countDigits(int n) {
    n = Math.abs(n);            // handle negative input
    if (n == 0) return 1;       // special case: 0 has exactly 1 digit
    int count = 0;
    while (n != 0) {
        count++;                // count this digit
        n = n / 10;             // chop off the last digit
    }
    return count;
}
// DRY RUN for n = 4536:
// n=4536 count=1, n=453 count=2, n=45 count=3, n=4 count=4, n=0 → stop
// Result: 4 ✅

// APPROACH 2: String length  (Simplest, 1 line)
public static int countDigitsStr(int n) {
    return String.valueOf(Math.abs(n)).length(); // convert to string, get length
}

// APPROACH 3: Math.log10  (Mathematical trick)
// log10(1000) = 3,  so digits = floor(log10(n)) + 1
public static int countDigitsLog(int n) {
    if (n == 0) return 1;
    return (int)(Math.log10(Math.abs(n))) + 1;
}

// Output:
// countDigits(4536) → 4    countDigits(7) → 1    countDigits(1000) → 4

N3 Sum of Digits of a Number▾

// Add all digits together.  253 → 2+5+3 = 10

// APPROACH 1: Loop with % (Standard)
public static int sumDigits(int n) {
    n = Math.abs(n);            // handle negatives
    int sum = 0;
    while (n != 0) {
        sum += n % 10;          // add last digit to sum
        n /= 10;                // remove last digit
    }
    return sum;
}
// DRY RUN for n = 253:
// n=253: sum=0+3=3,  n=25
// n=25:  sum=3+5=8,  n=2
// n=2:   sum=8+2=10, n=0  → stop
// Result: 10 ✅

// APPROACH 2: Using chars (String-based)
public static int sumDigitsStr(int n) {
    int sum = 0;
    for (char c : String.valueOf(Math.abs(n)).toCharArray()) {
        sum += (c - '0');   // trick: '5' - '0' = 5  (ASCII subtraction)
    }
    return sum;
}

// Output:
// sumDigits(253) → 10    sumDigits(999) → 27    sumDigits(0) → 0

N4 Check if Number is Palindrome▾

// A number is palindrome if it reads the same forwards and backwards.
// 121 → palindrome ✅    123 → not ❌

// APPROACH 1: Reverse and compare  (Standard)
public static boolean isNumPalindrome(int n) {
    if (n < 0) return false;    // negative numbers are never palindrome
    int original = n;           // save original to compare later
    int reversed = 0;
    while (n != 0) {
        reversed = reversed * 10 + n % 10; // build reversed number digit by digit
        n /= 10;
    }
    return original == reversed; // same? → palindrome
}
// DRY RUN for n = 121:
// n=121: rev=1, n=12
// n=12:  rev=12, n=1
// n=1:   rev=121, n=0
// original(121) == reversed(121) → true ✅

// APPROACH 2: String comparison  (Easiest)
public static boolean isNumPalindromeStr(int n) {
    String s = String.valueOf(Math.abs(n));
    return s.equals(new StringBuilder(s).reverse().toString());
}

// Output:
// isNumPalindrome(121)  → true    isNumPalindrome(1221) → true
// isNumPalindrome(123)  → false   isNumPalindrome(-121) → false

N5 Check if Number is Armstrong▾

// Armstrong Number: sum of each digit raised to power of (total digits) = original
// Example: 153 → 1³+5³+3³ = 1+125+27 = 153 ✅
// Example: 9474 → 9⁴+4⁴+7⁴+4⁴ = 6561+256+2401+256 = 9474 ✅

public static boolean isArmstrong(int n) {
    int original = n;
    int digits = String.valueOf(n).length();  // how many digits does n have?
    int sum = 0;
    while (n != 0) {
        int d = n % 10;                        // extract last digit
        sum += (int) Math.pow(d, digits);      // add digit^totalDigits
        n /= 10;                               // remove last digit
    }
    return sum == original;                    // does sum equal the original?
}
// DRY RUN for n = 153  (3 digits):
// d=3: sum=0+27=27,   n=15
// d=5: sum=27+125=152, n=1
// d=1: sum=152+1=153,  n=0
// 153 == 153 → true ✅

// Output:
// isArmstrong(153)  → true    isArmstrong(370)  → true
// isArmstrong(9474) → true    isArmstrong(100)  → false

2. Mathematical Logic

M1 Check if Number is Prime▾

// Prime: divisible ONLY by 1 and itself.  7 is prime, 6 is not.
// Key trick: only check divisors up to √n — saves time!

// APPROACH 1: Optimized √n check (Best for interviews)
public static boolean isPrime(int n) {
    if (n <= 1) return false;      // 0 and 1 are NOT prime
    if (n == 2) return true;       // 2 is the only even prime
    if (n % 2 == 0) return false;  // all even numbers > 2 are not prime
    for (int i = 3; i * i <= n; i += 2) { // check odd numbers up to √n only
        if (n % i == 0) return false;
    }
    return true;
}
// WHY i*i <= n?
// Divisors come in pairs: for 36 → (2,18)(3,12)(4,9)(6,6)
// After √36=6, divisors just repeat in reverse. No need to go further!

// DRY RUN for n = 17:
// 17%2 ≠ 0 → continue
// i=3: 3*3=9 ≤ 17, 17%3 ≠ 0
// i=5: 5*5=25 > 17 → loop ends
// return true ✅

// APPROACH 2: Brute force  (Simpler to understand)
public static boolean isPrimeSimple(int n) {
    if (n <= 1) return false;
    for (int i = 2; i < n; i++) {  // check every number from 2 to n-1
        if (n % i == 0) return false;
    }
    return true;
}

// Output:
// isPrime(2)  → true    isPrime(7)  → true    isPrime(17) → true
// isPrime(4)  → false   isPrime(1)  → false   isPrime(9)  → false

M2 Print Prime Numbers from 1 to N▾

// APPROACH 1: Use isPrime helper for each number
public static void printPrimes(int n) {
    for (int i = 2; i <= n; i++) {   // start from 2 (smallest prime)
        if (isPrime(i)) System.out.print(i + " ");
    }
}

// APPROACH 2: Sieve of Eratosthenes (Most Efficient — impress interviewers!)
// Idea: cross out all multiples of each prime starting from 2
public static void sieve(int n) {
    boolean[] isPrime = new boolean[n + 1];
    Arrays.fill(isPrime, true);         // assume all are prime
    isPrime[0] = isPrime[1] = false;    // 0 and 1 are not prime

    for (int i = 2; i * i <= n; i++) {
        if (isPrime[i]) {               // if i is still marked prime
            for (int j = i * i; j <= n; j += i) { // mark multiples of i as NOT prime
                isPrime[j] = false;     // starting from i*i (smaller already marked)
            }
        }
    }
    for (int i = 2; i <= n; i++)
        if (isPrime[i]) System.out.print(i + " ");
}
// HOW SIEVE WORKS for n=10:
// Initial: all true except index 0,1
// i=2: mark 4,6,8,10 as false
// i=3: mark 9 as false  (3*3=9)
// Result: 2 3 5 7 ✅

// Output: sieve(20) → 2 3 5 7 11 13 17 19

M3 Find GCD of Two Numbers▾

// GCD = Greatest Common Divisor = largest number that divides BOTH a and b
// GCD(12, 8) = 4  because 4 divides both 12 and 8

// APPROACH 1: Euclidean Algorithm – iterative (Best, O(log n))
// Formula: GCD(a,b) = GCD(b, a%b) until b = 0
public static int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;   // new b = remainder of a÷b
        a = temp;    // new a = old b
    }
    return a;        // when b=0, a holds the GCD
}
// DRY RUN for gcd(48, 18):
// a=48, b=18 → b=48%18=12, a=18
// a=18, b=12 → b=18%12=6,  a=12
// a=12, b=6  → b=12%6=0,   a=6
// b=0 → return 6 ✅

// APPROACH 2: Recursive
public static int gcdRec(int a, int b) {
    return b == 0 ? a : gcdRec(b, a % b);
}

// BONUS — LCM using GCD:
// LCM(a,b) = (a * b) / GCD(a,b)
public static int lcm(int a, int b) {
    return (a / gcd(a, b)) * b;  // divide first to prevent overflow
}

// Output:
// gcd(48, 18)  → 6      gcd(100, 75) → 25
// lcm(4, 6)    → 12     lcm(3, 5)    → 15

M4 Find Factorial of a Number▾

// Factorial: n! = n × (n-1) × (n-2) × ... × 1
// 5! = 5×4×3×2×1 = 120    0! = 1 (by definition)

// APPROACH 1: Iterative Loop (Best for interviews)
public static long factorial(int n) {
    if (n < 0) return -1;        // undefined for negatives
    long result = 1;             // use long — factorials grow very fast!
    for (int i = 2; i <= n; i++) {
        result *= i;             // multiply result by each number
    }
    return result;
}
// DRY RUN for n = 5:
// i=2: result=1×2=2
// i=3: result=2×3=6
// i=4: result=6×4=24
// i=5: result=24×5=120 ✅

// APPROACH 2: Recursive (Classic — must know!)
public static long factRec(int n) {
    if (n == 0 || n == 1) return 1;   // base case
    return n * factRec(n - 1);        // n × factorial of (n-1)
}
// CALL STACK for n=4:
// factRec(4) = 4 × factRec(3)
//              3 × factRec(2)
//              2 × factRec(1) = 1
// returns: 2×1=2 → 3×2=6 → 4×6=24 ✅

// Output:
// factorial(5) → 120    factorial(0) → 1    factorial(10) → 3628800

M5 Fibonacci Series▾

// Fibonacci: 0, 1, 1, 2, 3, 5, 8, 13, 21 ...
// Each number = sum of the previous two numbers

// APPROACH 1: Iterative (Most Efficient — O(n) time, O(1) space)
public static void printFibonacci(int n) {
    int a = 0, b = 1;
    System.out.print(a + " " + b + " ");  // print first two terms
    for (int i = 2; i < n; i++) {
        int c = a + b;           // next = previous two added together
        System.out.print(c + " ");
        a = b;                   // slide the window: a moves forward
        b = c;                   // b moves forward
    }
}
// DRY RUN for n=7:
// Print 0 1
// i=2: c=1, a=1,b=1 → print 1
// i=3: c=2, a=1,b=2 → print 2
// i=4: c=3, a=2,b=3 → print 3
// i=5: c=5, a=3,b=5 → print 5
// i=6: c=8, a=5,b=8 → print 8
// Output: 0 1 1 2 3 5 8 ✅

// APPROACH 2: Return Nth term
public static int nthFib(int n) {
    if (n <= 1) return n;       // fib(0)=0, fib(1)=1
    int a = 0, b = 1;
    for (int i = 2; i <= n; i++) { int c = a+b; a=b; b=c; }
    return b;
}

// Output:
// printFibonacci(8) → 0 1 1 2 3 5 8 13
// nthFib(6)         → 8

3. Basic Conditions

C1 Swap Two Numbers (With Temp Variable)▾

// Swap means exchange the values of two variables.
// a=5, b=10  →  a=10, b=5

// APPROACH 1: Using temp variable (SAFE — Always use this in production)
public static void swapWithTemp(int a, int b) {
    System.out.println("Before: a=" + a + ", b=" + b);
    int temp = a;    // Step 1: save a's value in temp  → temp=5
    a = b;           // Step 2: put b's value into a    → a=10
    b = temp;        // Step 3: put temp's value into b → b=5
    System.out.println("After:  a=" + a + ", b=" + b);
}
// DRY RUN for a=5, b=10:
// temp=5 → a=10 → b=5 ✅

// Output: Before: a=5, b=10   After: a=10, b=5

C2 Swap Two Numbers (Without Temp Variable)▾

// APPROACH 1: Arithmetic – using + and -
public static void swapNoTemp(int a, int b) {
    System.out.println("Before: a=" + a + ", b=" + b);
    a = a + b;   // a = 5+10 = 15  (a now holds the sum)
    b = a - b;   // b = 15-10 = 5  (subtract original b → get original a)
    a = a - b;   // a = 15-5  = 10 (subtract original a → get original b)
    System.out.println("After:  a=" + a + ", b=" + b);
}
// ⚠️ Risk: overflow if a+b exceeds Integer.MAX_VALUE

// APPROACH 2: XOR Bitwise (No overflow risk — Pro technique!)
public static void swapXOR(int a, int b) {
    a = a ^ b;   // a = a XOR b
    b = a ^ b;   // b = (a XOR b) XOR b = a  (original)
    a = a ^ b;   // a = (a XOR b) XOR a = b  (original)
    System.out.println("After XOR: a=" + a + ", b=" + b);
}
// XOR trick: x ^ x = 0  and  x ^ 0 = x

// Output: Before: a=5, b=10   After: a=10, b=5

C3 Find Largest of Three Numbers▾

// APPROACH 1: if-else chain (Clear and readable)
public static int largest3(int a, int b, int c) {
    if (a >= b && a >= c) return a;  // a is largest
    else if (b >= c)      return b;  // b is largest
    else                  return c;  // c is largest
}

// APPROACH 2: Nested Math.max (Cleanest)
public static int largest3V2(int a, int b, int c) {
    return Math.max(a, Math.max(b, c)); // find max of b&c, then compare with a
}

// APPROACH 3: Ternary operator
public static int largest3V3(int a, int b, int c) {
    int ab = (a > b) ? a : b;          // max of a and b
    return (ab > c) ? ab : c;          // max of ab and c
}

// Output:
// largest3(5, 9, 3)    → 9     largest3(20, 15, 20) → 20
// largest3(-1, -5, -3) → -1

C4 Check Even or Odd Number▾

// Even: divisible by 2 (last digit 0,2,4,6,8)
// Odd:  NOT divisible by 2 (last digit 1,3,5,7,9)

// APPROACH 1: Modulo operator (Standard)
public static String evenOdd(int n) {
    return (n % 2 == 0) ? n + " is Even" : n + " is Odd";
}

// APPROACH 2: Bitwise AND (Fastest — used in performance-critical code)
// How it works: even numbers end in 0 in binary, odd end in 1
// n & 1  checks the last bit only
public static String evenOddBit(int n) {
    return ((n & 1) == 0) ? n + " is Even" : n + " is Odd";
}
// Binary examples:
// 4  = 0100  →  0100 & 0001 = 0  → Even ✅
// 7  = 0111  →  0111 & 0001 = 1  → Odd  ✅
// 10 = 1010  →  1010 & 0001 = 0  → Even ✅

// Output:
// evenOdd(4) → Even    evenOdd(7) → Odd    evenOdd(-6) → Even

C5 Sum of First N Natural Numbers▾

// Natural numbers: 1, 2, 3, 4 ... N

// APPROACH 1: Formula — O(1) INSTANT! (Best)
// Sum = N × (N+1) / 2  ← Gauss formula
public static long sumN(int n) {
    return (long) n * (n + 1) / 2;  // cast to long to prevent overflow
}
// Example: n=100 → 100×101/2 = 5050

// APPROACH 2: For loop — O(n)
public static long sumNLoop(int n) {
    long sum = 0;
    for (int i = 1; i <= n; i++) sum += i;
    return sum;
}
// DRY RUN for n=5:
// i=1:sum=1, i=2:sum=3, i=3:sum=6, i=4:sum=10, i=5:sum=15 ✅

// APPROACH 3: Recursive
public static long sumNRec(int n) {
    return (n == 0) ? 0 : n + sumNRec(n - 1);
}

// Output:
// sumN(100) → 5050    sumN(10) → 55    sumN(5) → 15

1. String Basics

S1 Reverse a String▾

// APPROACH 1: For loop (Without inbuilt — best for interviews)
public static String reverseStr(String s) {
    String result = "";
    for (int i = s.length() - 1; i >= 0; i--) {
        result += s.charAt(i);  // add each char from end to start
    }
    return result;
}

// APPROACH 2: Two Pointer on char array (Efficient, O(n))
public static String reverseV2(String s) {
    char[] arr = s.toCharArray();   // "Hello" → ['H','e','l','l','o']
    int left = 0, right = arr.length - 1;
    while (left < right) {
        char temp = arr[left];      // swap left and right chars
        arr[left] = arr[right];
        arr[right] = temp;
        left++;  right--;           // move pointers inward
    }
    return new String(arr);
}
// DRY RUN for "Java":
// arr=[J,a,v,a]
// left=0,right=3 → swap J,a → [a,a,v,J]
// left=1,right=2 → swap a,v → [a,v,a,J]
// Result: "avaJ" ✅

// APPROACH 3: StringBuilder.reverse() (Inbuilt — simplest)
public static String reverseV3(String s) {
    return new StringBuilder(s).reverse().toString();
}

// Output:
// reverseStr("Hello") → "olleH"    reverseV3("Java") → "avaJ"

S2 Check if String is Palindrome▾

// Palindrome: reads same forwards and backwards.  "racecar" ✅  "hello" ❌

// APPROACH 1: Two Pointer (Best — O(n), no extra space)
public static boolean isPalindromeStr(String s) {
    s = s.toLowerCase();         // make comparison case-insensitive
    int left = 0, right = s.length() - 1;
    while (left < right) {
        if (s.charAt(left) != s.charAt(right)) return false; // mismatch!
        left++;  right--;
    }
    return true;
}
// DRY RUN for "racecar":
// l=0,r=6: r==r ✅   l=1,r=5: a==a ✅   l=2,r=4: c==c ✅
// l=3=r=3: pointers meet → stop → return true ✅

// APPROACH 2: Reverse and compare (Simple)
public static boolean isPalindromeV2(String s) {
    String low = s.toLowerCase();
    return low.equals(new StringBuilder(low).reverse().toString());
}

// Output:
// isPalindromeStr("racecar") → true     isPalindromeStr("Madam") → true
// isPalindromeStr("hello")   → false

S3 Count Number of Words in a String▾

// APPROACH 1: split() with \\s+ (Handles multiple spaces, tabs)
public static int countWords(String s) {
    s = s.trim();                  // remove leading/trailing spaces
    if (s.isEmpty()) return 0;
    return s.split("\\s+").length; // \\s+ = one or more whitespace chars
}

// APPROACH 2: Manual loop (Without inbuilt)
public static int countWordsManual(String s) {
    int count = 0;
    boolean inWord = false;
    for (char c : s.toCharArray()) {
        if (c != ' ' && !inWord) { // entering a new word
            count++;
            inWord = true;
        } else if (c == ' ') {
            inWord = false;         // leaving a word
        }
    }
    return count;
}
// DRY RUN for "Hello World Java":
// H→inWord=true,count=1  space→inWord=false
// W→inWord=true,count=2  space→inWord=false
// J→inWord=true,count=3  → end
// Result: 3 ✅

// Output:
// countWords("Hello World Java") → 3    countWords("  Hi   there  ") → 2

S4 Count Vowels and Consonants▾

// Vowels: a e i o u    Consonants: all other alphabets

public static void countVC(String s) {
    s = s.toLowerCase();           // normalize: treat A and a the same
    int vowels = 0, consonants = 0;
    for (char c : s.toCharArray()) {
        if (c >= 'a' && c <= 'z') {          // only process alphabet chars
            if ("aeiou".indexOf(c) != -1) {   // is it a vowel?
                vowels++;
            } else {
                consonants++;                  // it's a consonant
            }
        }
        // spaces, digits, symbols are simply ignored
    }
    System.out.println("Vowels: " + vowels + ", Consonants: " + consonants);
}
// DRY RUN for "Hello":
// h→consonant(1)  e→vowel(1)  l→consonant(2)  l→consonant(3)  o→vowel(2)
// Vowels=2, Consonants=3 ✅

// Output:
// countVC("Java")    → Vowels: 2, Consonants: 2
// countVC("Hello!")  → Vowels: 2, Consonants: 3

S5 Remove Spaces from String▾

// APPROACH 1: replaceAll with regex (Easiest — 1 line)
public static String removeSpaces(String s) {
    return s.replaceAll("\\s", ""); // \\s matches space, tab, newline — replaces with ""
}

// APPROACH 2: Loop (Without inbuilt — for interview)
public static String removeSpacesManual(String s) {
    StringBuilder sb = new StringBuilder();
    for (char c : s.toCharArray()) {
        if (c != ' ') sb.append(c);  // only keep non-space characters
    }
    return sb.toString();
}

// APPROACH 3: Stream (Java 8+)
public static String removeSpacesStream(String s) {
    return s.chars()
            .filter(c -> c != ' ')
            .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
            .toString();
}

// Output:
// removeSpaces("Hello World") → "HelloWorld"
// removeSpaces("J a v a")     → "Java"

2. String Manipulation

S6 Reverse Each Word in a String▾

// Input:  "Hello World Java"
// Output: "olleH dlroW avaJ"   — each word reversed, order stays same

public static String reverseEachWord(String s) {
    String[] words = s.split(" ");         // split into array of words
    StringBuilder result = new StringBuilder();
    for (String word : words) {
        result.append(new StringBuilder(word).reverse()); // reverse each word
        result.append(" ");                 // add space separator
    }
    return result.toString().trim();        // remove trailing space
}
// ITERATION for "Hi Java":
// word="Hi"   → "iH"
// word="Java" → "avaJ"
// Result: "iH avaJ" ✅

// Output:
// reverseEachWord("Hello World") → "olleH dlroW"
// reverseEachWord("Java is fun") → "avaJ si nuf"

S7 Reverse Word Order in Sentence▾

// Input:  "Hello World Java"
// Output: "Java World Hello"   — word ORDER reversed, each word stays same

// APPROACH 1: Split → reverse array → join
public static String reverseWordOrder(String s) {
    String[] words = s.trim().split("\\s+"); // split on any whitespace
    int left = 0, right = words.length - 1;
    while (left < right) {
        String tmp = words[left];   // swap words at left and right positions
        words[left] = words[right];
        words[right] = tmp;
        left++;  right--;
    }
    return String.join(" ", words); // join array back into sentence
}
// DRY RUN for "Java is great":
// words = ["Java","is","great"]
// swap index 0 and 2: ["great","is","Java"]
// Result: "great is Java" ✅

// APPROACH 2: Collections.reverse (One-liner style)
public static String reverseWordOrderV2(String s) {
    List list = new ArrayList<>(Arrays.asList(s.trim().split("\\s+")));
    Collections.reverse(list);
    return String.join(" ", list);
}

// Output:
// reverseWordOrder("Hello World Java") → "Java World Hello"

S8 Convert String to Integer (without parseInt)▾

// APPROACH 1: Manual conversion (Shows how parseInt works internally)
public static int strToInt(String s) {
    int result = 0;
    boolean negative = false;
    int start = 0;
    if (s.charAt(0) == '-') { negative = true; start = 1; } // handle sign
    for (int i = start; i < s.length(); i++) {
        char c = s.charAt(i);
        if (c < '0' || c > '9') throw new IllegalArgumentException("Invalid: " + c);
        int digit = c - '0';              // ASCII trick: '5'-'0' = 5
        result = result * 10 + digit;     // build number digit by digit
    }
    return negative ? -result : result;
}
// DRY RUN for "123":
// c='1': digit=1, result=1
// c='2': digit=2, result=12
// c='3': digit=3, result=123 ✅

// APPROACH 2: Integer.parseInt (Standard)
public static int strToIntBuiltin(String s) {
    return Integer.parseInt(s);  // throws NumberFormatException if invalid
}

// Output:
// strToInt("123") → 123    strToInt("-45") → -45

S9 Check if String Contains Only Digits▾

// APPROACH 1: Loop (Without inbuilt)
public static boolean isAllDigits(String s) {
    if (s == null || s.isEmpty()) return false;
    for (char c : s.toCharArray()) {
        if (c < '0' || c > '9') return false; // found a non-digit
    }
    return true;
}

// APPROACH 2: matches() with regex (Simplest)
public static boolean isAllDigitsRegex(String s) {
    return s != null && s.matches("\\d+"); // \\d = digit, + = one or more
}

// APPROACH 3: Character.isDigit() with stream (Java 8)
public static boolean isAllDigitsStream(String s) {
    return s != null && !s.isEmpty() && s.chars().allMatch(Character::isDigit);
}

// Output:
// isAllDigits("12345") → true    isAllDigits("123a5") → false

3. String Frequency Problems

F1 Count Occurrence of Each Character▾

// APPROACH 1: LinkedHashMap (Best — handles all chars, preserves order)
public static void charFrequency(String s) {
    Map map = new LinkedHashMap<>();
    for (char c : s.toCharArray()) {
        map.put(c, map.getOrDefault(c, 0) + 1); // if key exists add 1, else put 1
    }
    for (Map.Entry e : map.entrySet()) {
        System.out.println("'" + e.getKey() + "' → " + e.getValue());
    }
}

// APPROACH 2: int array (Only lowercase a-z — faster, less memory)
public static void charFreqArray(String s) {
    int[] freq = new int[26];  // index 0=a, 1=b, ..., 25=z
    for (char c : s.toLowerCase().toCharArray()) {
        if (c >= 'a' && c <= 'z') freq[c - 'a']++; // map 'a'→0, 'b'→1 etc.
    }
    for (int i = 0; i < 26; i++) {
        if (freq[i] > 0) System.out.println((char)('a' + i) + " → " + freq[i]);
    }
}
// DRY RUN for "aabb":
// 'a':map={a:1}, 'a':map={a:2}, 'b':map={a:2,b:1}, 'b':map={a:2,b:2}
// Output: a→2, b→2 ✅

// Output for "programming": p→1, r→2, o→1, g→2, a→1, m→2, i→1, n→1

F2 Find First Non-Repeating Character▾

// First character that appears ONLY once.   "aabbcd" → 'c'

// APPROACH 1: LinkedHashMap — two passes (Best)
public static char firstNonRepeating(String s) {
    Map map = new LinkedHashMap<>(); // preserves insertion order
    for (char c : s.toCharArray())
        map.put(c, map.getOrDefault(c, 0) + 1); // pass 1: build frequency map
    for (Map.Entry e : map.entrySet())
        if (e.getValue() == 1) return e.getKey(); // pass 2: first with count=1
    return '_'; // no non-repeating char found
}

// APPROACH 2: int array — two passes (Faster for a-z)
public static char firstNonRepArray(String s) {
    int[] freq = new int[256]; // all ASCII characters
    for (char c : s.toCharArray()) freq[c]++;      // pass 1: count
    for (char c : s.toCharArray())                 // pass 2: find first with 1
        if (freq[c] == 1) return c;
    return '_';
}
// DRY RUN for "aabbcd":
// map: a→2, b→2, c→1, d→1
// first entry with value=1 → 'c' ✅

// Output:
// firstNonRepeating("aabbcd")   → c
// firstNonRepeating("leetcode") → l
// firstNonRepeating("aabb")     → _

F3 Find Duplicate Characters in String▾

// Characters that appear MORE THAN ONCE

// APPROACH 1: HashMap — count then filter
public static void findDuplicates(String s) {
    Map map = new LinkedHashMap<>();
    for (char c : s.toLowerCase().toCharArray())
        map.put(c, map.getOrDefault(c, 0) + 1);
    System.out.print("Duplicates: ");
    for (Map.Entry e : map.entrySet())
        if (e.getValue() > 1)
            System.out.print(e.getKey() + "(" + e.getValue() + ") ");
}

// APPROACH 2: Two Sets (seen + duplicates)
public static void findDuplicatesSet(String s) {
    Set seen = new HashSet<>();
    Set dups = new LinkedHashSet<>();
    for (char c : s.toCharArray())
        if (!seen.add(c)) dups.add(c); // add() returns false if already present
    System.out.println("Duplicates: " + dups);
}
// DRY RUN for "programming":
// seen: p,r→ r again! dup={r}  g→ g again! dup={r,g}  m→ m again! dup={r,g,m}

// Output:
// findDuplicates("programming") → r(2) g(2) m(2)

4. String Logical Problems

L1 Check if Two Strings are Anagram▾

// Anagram: same characters, different arrangement.  "listen" = "silent" ✅

// APPROACH 1: Sort both and compare (Simple, O(n log n))
public static boolean isAnagram(String a, String b) {
    if (a.length() != b.length()) return false; // lengths must match
    char[] ca = a.toLowerCase().toCharArray();
    char[] cb = b.toLowerCase().toCharArray();
    Arrays.sort(ca);  Arrays.sort(cb);           // sort both
    return Arrays.equals(ca, cb);                // compare sorted arrays
}

// APPROACH 2: Frequency array (Better, O(n) no sorting)
public static boolean isAnagramV2(String a, String b) {
    if (a.length() != b.length()) return false;
    int[] freq = new int[26];
    for (int i = 0; i < a.length(); i++) {
        freq[a.charAt(i) - 'a']++;   // +1 for each char in a
        freq[b.charAt(i) - 'a']--;   // -1 for each char in b
    }
    for (int f : freq) if (f != 0) return false; // any mismatch → not anagram
    return true;
}
// DRY RUN for "listen" vs "silent":
// After sort: "eilnst" == "eilnst" → true ✅

// Output:
// isAnagram("listen","silent")   → true
// isAnagram("Anagram","Nagaram") → true
// isAnagram("hello","world")     → false

L2 Remove Duplicate Characters from String▾

// Keep only FIRST occurrence of each character.
// "programming" → "progamin"

// APPROACH 1: LinkedHashSet (Best — preserves order, auto-removes dups)
public static String removeDups(String s) {
    Set seen = new LinkedHashSet<>();
    for (char c : s.toCharArray()) seen.add(c); // Set ignores duplicates automatically
    StringBuilder sb = new StringBuilder();
    for (char c : seen) sb.append(c);
    return sb.toString();
}

// APPROACH 2: Manual boolean array (Without collections)
public static String removeDupsManual(String s) {
    boolean[] seen = new boolean[256]; // one slot per ASCII character
    StringBuilder sb = new StringBuilder();
    for (char c : s.toCharArray()) {
        if (!seen[c]) {       // first time seeing this char?
            sb.append(c);     // add it to result
            seen[c] = true;   // mark as seen
        }
    }
    return sb.toString();
}
// DRY RUN for "aabbcc":
// a:new→add  a:seen→skip  b:new→add  b:seen→skip  c:new→add  c:seen→skip
// Result: "abc" ✅

// Output:
// removeDups("programming") → "progamin"    removeDups("aabbcc") → "abc"

L3 Find Largest Word in Sentence▾

// Largest = word with most characters
// "Java is a programming language" → "programming" (11 chars)

// APPROACH 1: Loop — compare lengths
public static String largestWord(String s) {
    String[] words = s.trim().split("\\s+");
    String largest = "";
    for (String word : words) {
        if (word.length() > largest.length()) {
            largest = word;  // update if this word is longer
        }
    }
    return largest;
}
// ITERATION for "Java is a programming language":
// "Java"(4) > ""(0)           → largest="Java"
// "is"(2) < "Java"(4)         → skip
// "a"(1) < "Java"(4)          → skip
// "programming"(11) > "Java"  → largest="programming"
// "language"(8) < "programming" → skip
// Result: "programming" ✅

// APPROACH 2: Stream (Java 8 — elegant)
public static String largestWordStream(String s) {
    return Arrays.stream(s.trim().split("\\s+"))
                 .max(Comparator.comparingInt(String::length))
                 .orElse("");
}

// Output:
// largestWord("Java is programming")   → "programming"
// largestWord("Hi there everyone")     → "everyone"

1. Array – Basic Operations

A1 Find Largest Element▾

// APPROACH 1: Loop (Without inbuilt — Best for interview)
public static int findLargest(int[] arr) {
    int max = arr[0];            // assume first element is largest
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > max) max = arr[i]; // update max if current is bigger
    }
    return max;
}
// DRY RUN for [3, 7, 1, 9, 4]:
// max=3 → arr[1]=7>3 → max=7 → arr[2]=1<7 → arr[3]=9>7 → max=9 → arr[4]=4<9
// Result: 9 ✅

// APPROACH 2: Arrays.stream (Java 8 — 1 line)
public static int findLargestStream(int[] arr) {
    return Arrays.stream(arr).max().getAsInt();
}

// Output: findLargest([3,7,1,9,4]) → 9

A2 Find Smallest Element▾

// Same logic as largest — just flip the comparison
public static int findSmallest(int[] arr) {
    int min = arr[0];            // assume first element is smallest
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] < min) min = arr[i]; // update if current is smaller
    }
    return min;
}
// DRY RUN for [3, 7, 1, 9, 4]:
// min=3 → 7>3 skip → 1<3 min=1 → 9>1 skip → 4>1 skip
// Result: 1 ✅

// APPROACH 2: Stream
public static int findSmallestStream(int[] arr) {
    return Arrays.stream(arr).min().getAsInt();
}

A3 Find Second Largest Element▾

// APPROACH 1: Single pass — track both max and second max
public static int secondLargest(int[] arr) {
    int max = Integer.MIN_VALUE, second = Integer.MIN_VALUE;
    for (int n : arr) {
        if (n > max) {
            second = max;  // old max becomes second
            max = n;       // new max found
        } else if (n > second && n != max) {
            second = n;    // update second if bigger than current second (and not equal to max)
        }
    }
    return second;
}
// DRY RUN for [3, 7, 1, 9, 4]:
// n=3: max=3, second=MIN
// n=7: 7>3 → second=3, max=7
// n=1: 1<7 and 1<3 → skip
// n=9: 9>7 → second=7, max=9
// n=4: 4<9 and 4>7? No. 4>second(7)? No → skip
// Result: 7 ✅

// APPROACH 2: Sort (Simple but O(n log n))
public static int secondLargestSort(int[] arr) {
    int[] sorted = Arrays.copyOf(arr, arr.length);
    Arrays.sort(sorted);  // sort ascending
    return sorted[sorted.length - 2]; // second from end
}
// ⚠️ Won't work for duplicates like [5,5,3] — use APPROACH 1 instead

// Output: secondLargest([3,7,1,9,4]) → 7

A4 Reverse an Array▾

// APPROACH 1: Two pointer (In-place, no extra space)
public static void reverseArray(int[] arr) {
    int left = 0, right = arr.length - 1;
    while (left < right) {
        int temp = arr[left];    // swap arr[left] and arr[right]
        arr[left] = arr[right];
        arr[right] = temp;
        left++;  right--;        // move pointers inward
    }
}
// DRY RUN for [1, 2, 3, 4, 5]:
// l=0,r=4: swap 1,5 → [5,2,3,4,1]
// l=1,r=3: swap 2,4 → [5,4,3,2,1]
// l=2,r=2: pointers meet → stop
// Result: [5,4,3,2,1] ✅

// APPROACH 2: New array (If you need original preserved)
public static int[] reverseArrayNew(int[] arr) {
    int[] result = new int[arr.length];
    for (int i = 0; i < arr.length; i++)
        result[i] = arr[arr.length - 1 - i]; // fill from end of original
    return result;
}

A5 Check if Array is Sorted▾

// Sorted (ascending): each element <= next element
// [1,2,3,4,5] ✅   [1,3,2,4] ❌

public static boolean isSorted(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        if (arr[i] > arr[i + 1]) return false; // found a pair out of order
    }
    return true; // all pairs were in order
}
// DRY RUN for [1, 3, 2, 4]:
// i=0: arr[0]=1 <= arr[1]=3 ✅
// i=1: arr[1]=3 > arr[2]=2 ❌ → return false ✅

// Output:
// isSorted([1,2,3,4,5]) → true    isSorted([1,3,2,4]) → false

2. Array – Rotation Problems

R1 Left Rotate Array by One Position▾

// Left rotate: first element goes to end
// [1,2,3,4,5] → [2,3,4,5,1]

public static void leftRotateOne(int[] arr) {
    int first = arr[0];                      // save first element
    for (int i = 0; i < arr.length - 1; i++) {
        arr[i] = arr[i + 1];                 // shift each element one step left
    }
    arr[arr.length - 1] = first;             // put saved element at end
}
// DRY RUN for [1,2,3,4,5]:
// first=1
// arr=[2,3,4,5,5] (shifting)
// arr[4]=1 → [2,3,4,5,1] ✅

R2 Left Rotate Array by K Positions▾

// [1,2,3,4,5], K=2 → [3,4,5,1,2]

// APPROACH 1: Reversal Algorithm (Most Efficient — O(n), O(1) space)
// Step 1: Reverse first K elements
// Step 2: Reverse remaining elements
// Step 3: Reverse entire array
public static void leftRotateK(int[] arr, int k) {
    int n = arr.length;
    k = k % n;              // handle k > n  (e.g. k=7 on size 5 = k=2)
    reverse(arr, 0, k - 1); // reverse [0..k-1]
    reverse(arr, k, n - 1); // reverse [k..n-1]
    reverse(arr, 0, n - 1); // reverse entire array
}
public static void reverse(int[] arr, int l, int r) {
    while (l < r) { int t=arr[l]; arr[l]=arr[r]; arr[r]=t; l++; r--; }
}
// DRY RUN for [1,2,3,4,5], K=2:
// Reverse [0..1]: [2,1,3,4,5]
// Reverse [2..4]: [2,1,5,4,3]
// Reverse all:    [3,4,5,1,2] ✅

// APPROACH 2: Using temp array (Simpler to understand)
public static void leftRotateKSimple(int[] arr, int k) {
    int n = arr.length;  k = k % n;
    int[] temp = Arrays.copyOfRange(arr, 0, k); // save first k elements
    for (int i = 0; i < n - k; i++) arr[i] = arr[i + k]; // shift left
    for (int i = 0; i < k; i++) arr[n - k + i] = temp[i]; // fill end
}

R3 Right Rotate Array by K Positions▾

// [1,2,3,4,5], K=2 → [4,5,1,2,3]
// Right rotate K = Left rotate (n-K)

public static void rightRotateK(int[] arr, int k) {
    int n = arr.length;
    k = k % n;              // normalize k
    // Right rotation K = Left rotation (n-K)
    reverse(arr, 0, n - k - 1); // reverse first (n-k) elements
    reverse(arr, n - k, n - 1); // reverse last k elements
    reverse(arr, 0, n - 1);     // reverse entire array
}
// DRY RUN for [1,2,3,4,5], K=2 (n=5):
// Reverse [0..2]: [3,2,1,4,5]
// Reverse [3..4]: [3,2,1,5,4]
// Reverse all:    [4,5,1,2,3] ✅

3. Array – Duplicate & Frequency Problems

D1 Remove Duplicates from Sorted Array▾

// Since array is SORTED, duplicates are always adjacent.
// [1,1,2,2,3,4,4] → [1,2,3,4] — return count of unique elements

// Two Pointer technique (O(n), O(1) space — Best)
public static int removeDuplicatesSorted(int[] arr) {
    if (arr.length == 0) return 0;
    int j = 0; // j = position to place next unique element
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] != arr[j]) { // found a new unique element
            j++;                 // advance write pointer
            arr[j] = arr[i];    // write it to correct position
        }
    }
    return j + 1; // number of unique elements
}
// DRY RUN for [1,1,2,2,3]:
// j=0 (arr[j]=1)
// i=1: arr[1]=1 == arr[j]=1 → skip
// i=2: arr[2]=2 != arr[j]=1 → j=1, arr[1]=2 → [1,2,2,2,3]
// i=3: arr[3]=2 == arr[j]=2 → skip
// i=4: arr[4]=3 != arr[j]=2 → j=2, arr[2]=3 → [1,2,3,2,3]
// return 3 ✅  (first 3 elements: [1,2,3])

D2 Find Duplicate Elements in Array▾

// Find all elements that appear more than once
// [1,2,3,2,4,3] → duplicates: 2, 3

// APPROACH 1: HashSet — add and detect duplicates
public static void findDuplicatesArr(int[] arr) {
    Set seen = new HashSet<>();
    Set dups = new LinkedHashSet<>();
    for (int n : arr) {
        if (!seen.add(n)) dups.add(n); // add() returns false = already existed
    }
    System.out.println("Duplicates: " + dups);
}

// APPROACH 2: HashMap frequency count
public static void findDuplicatesMap(int[] arr) {
    Map map = new LinkedHashMap<>();
    for (int n : arr) map.put(n, map.getOrDefault(n, 0) + 1);
    for (Map.Entry e : map.entrySet())
        if (e.getValue() > 1) System.out.print(e.getKey() + " ");
}
// DRY RUN for [1,2,3,2,4,3]:
// seen: 1,2,3 → 2 already! dup={2} → 4 → 3 already! dup={2,3}
// Output: 2 3 ✅

D3 Count Frequency of Elements▾

// Print how many times each element appears
// [1,2,2,3,3,3] → 1→1, 2→2, 3→3

public static void countFrequency(int[] arr) {
    Map map = new LinkedHashMap<>();
    for (int n : arr)
        map.put(n, map.getOrDefault(n, 0) + 1); // count each element
    for (Map.Entry e : map.entrySet())
        System.out.println(e.getKey() + " → " + e.getValue());
}
// DRY RUN for [1,2,2,3]:
// 1→1, 2→1 then 2→2, 3→1
// Output: 1→1, 2→2, 3→1 ✅

D4 Find Element Appearing Once (Others Appear Twice)▾

// [2, 3, 2, 4, 3] → answer is 4  (only 4 appears once)

// APPROACH 1: XOR trick (Most elegant — O(n), O(1) space!)
// Key property: x ^ x = 0  and  x ^ 0 = x
// So XOR of all elements — pairs cancel out, leaving the single element
public static int findSingle(int[] arr) {
    int result = 0;
    for (int n : arr) result ^= n;  // XOR all elements
    return result;
}
// DRY RUN for [2,3,2,4,3]:
// result = 0^2=2 → 2^3=1 → 1^2=3 → 3^4=7 → 7^3=4
// Result: 4 ✅ (pairs cancel: 2^2=0, 3^3=0)

// APPROACH 2: HashMap (Easier to understand)
public static int findSingleMap(int[] arr) {
    Map map = new HashMap<>();
    for (int n : arr) map.put(n, map.getOrDefault(n,0)+1);
    for (Map.Entry e : map.entrySet())
        if (e.getValue() == 1) return e.getKey();
    return -1;
}

// Output: findSingle([2,3,2,4,3]) → 4

4. Array – Missing / Special Elements

ME1 Find Missing Number (1 to N)▾

// Array has n-1 elements from 1 to n, one number missing.
// [1,2,4,5] from 1-5 → missing is 3

// APPROACH 1: Sum formula (Best — O(n), O(1))
// Expected sum of 1 to N = N*(N+1)/2
// Missing = Expected sum − Actual sum
public static int findMissing(int[] arr, int n) {
    int expected = n * (n + 1) / 2;  // what the sum SHOULD be
    int actual = 0;
    for (int x : arr) actual += x;   // what the sum actually is
    return expected - actual;         // difference = missing number
}
// DRY RUN for [1,2,4,5], n=5:
// expected = 5*6/2 = 15
// actual   = 1+2+4+5 = 12
// missing  = 15-12 = 3 ✅

// APPROACH 2: XOR (Handles large numbers without overflow)
public static int findMissingXOR(int[] arr, int n) {
    int xor = 0;
    for (int i = 1; i <= n; i++) xor ^= i;   // XOR all 1 to N
    for (int x : arr) xor ^= x;              // XOR with all array elements
    return xor;  // all pairs cancel, leaving the missing number
}

ME2 Maximum Consecutive Ones▾

// In binary array, find longest run of consecutive 1s
// [1,1,0,1,1,1] → 3

public static int maxConsecutiveOnes(int[] arr) {
    int maxCount = 0;    // overall maximum
    int count = 0;       // current run of ones
    for (int n : arr) {
        if (n == 1) {
            count++;                       // extend current run
            maxCount = Math.max(maxCount, count); // update max if needed
        } else {
            count = 0;                     // reset run on seeing 0
        }
    }
    return maxCount;
}
// DRY RUN for [1,1,0,1,1,1]:
// n=1:count=1,max=1  n=1:count=2,max=2  n=0:count=0
// n=1:count=1,max=2  n=1:count=2,max=2  n=1:count=3,max=3
// Result: 3 ✅

// Output:
// maxConsecutiveOnes([1,1,0,1,1,1]) → 3
// maxConsecutiveOnes([0,0,1,0])     → 1

5. Array – Multiple Array Operations

MO1 Merge Two Sorted Arrays▾

// [1,3,5] + [2,4,6] → [1,2,3,4,5,6]
// Both arrays already sorted — merge without sorting again

public static int[] mergeSorted(int[] a, int[] b) {
    int i = 0, j = 0, k = 0;
    int[] result = new int[a.length + b.length];
    while (i < a.length && j < b.length) {
        if (a[i] <= b[j]) result[k++] = a[i++]; // pick smaller element
        else               result[k++] = b[j++];
    }
    while (i < a.length) result[k++] = a[i++]; // copy remaining from a
    while (j < b.length) result[k++] = b[j++]; // copy remaining from b
    return result;
}
// DRY RUN for [1,3,5] and [2,4,6]:
// i=0,j=0: 1<2 → result[0]=1, i=1
// i=1,j=0: 3>2 → result[1]=2, j=1
// i=1,j=1: 3<4 → result[2]=3, i=2
// i=2,j=1: 5>4 → result[3]=4, j=2
// i=2,j=2: 5<6 → result[4]=5, i=3 → loop ends
// copy remaining b: result[5]=6
// Result: [1,2,3,4,5,6] ✅

MO2 Intersection of Two Arrays▾

// Elements that exist in BOTH arrays (no duplicates)
// [1,2,3,4] ∩ [3,4,5,6] → [3,4]

public static List intersection(int[] a, int[] b) {
    Set setA = new HashSet<>();
    for (int x : a) setA.add(x);          // put all of a into a set

    Set result = new LinkedHashSet<>();
    for (int x : b) {
        if (setA.contains(x)) result.add(x); // if b's element exists in a → common
    }
    return new ArrayList<>(result);
}
// DRY RUN for [1,2,3,4] and [3,4,5,6]:
// setA = {1,2,3,4}
// b: 3→in setA! 4→in setA! 5→not in setA. 6→not in setA.
// result = {3,4} ✅

MO3 Union of Two Arrays▾

// All unique elements from BOTH arrays combined
// [1,2,3] ∪ [3,4,5] → [1,2,3,4,5]

public static List union(int[] a, int[] b) {
    Set set = new LinkedHashSet<>(); // preserves insertion order
    for (int x : a) set.add(x);  // add all of a
    for (int x : b) set.add(x);  // add all of b (duplicates auto-ignored by Set)
    return new ArrayList<>(set);
}
// LinkedHashSet automatically handles:
// 1. Removing duplicates (Set property)
// 2. Preserving insertion order (Linked property)

// Output:
// union([1,2,3],[3,4,5]) → [1,2,3,4,5]

6. Array – Medium Logical Problems

ML1 Two Sum Problem▾

// Find if any two elements sum to a target value
// [2,7,4,3], target=9 → 2+7=9 ✅

// APPROACH 1: HashMap (O(n) — Best)
public static void twoSum(int[] arr, int target) {
    Map map = new HashMap<>(); // stores value → index
    for (int i = 0; i < arr.length; i++) {
        int complement = target - arr[i];  // what number do we need?
        if (map.containsKey(complement)) {
            System.out.println("Pair found: " + complement + " + " + arr[i]);
        }
        map.put(arr[i], i);               // store current element
    }
}
// DRY RUN for [2,7,4,3], target=9:
// i=0: need 9-2=7 → not in map. map={2:0}
// i=1: need 9-7=2 → 2 IS in map! → Print: 2+7=9 ✅

// APPROACH 2: Brute force (O(n²) — Easy to understand)
public static void twoSumBrute(int[] arr, int target) {
    for (int i = 0; i < arr.length; i++)
        for (int j = i+1; j < arr.length; j++)
            if (arr[i] + arr[j] == target)
                System.out.println(arr[i] + " + " + arr[j]);
}

ML2 Find Majority Element▾

// Majority element: appears more than n/2 times
// [3,3,4,2,3,3,3] → 3  (appears 5 times in array of 7)

// APPROACH 1: Boyer-Moore Voting Algorithm (O(n), O(1) — Pro!)
public static int majorityElement(int[] arr) {
    int candidate = arr[0], votes = 1;
    for (int i = 1; i < arr.length; i++) {
        if (votes == 0) {
            candidate = arr[i]; // reset candidate
            votes = 1;
        } else if (arr[i] == candidate) {
            votes++;             // same element — add vote
        } else {
            votes--;             // different element — cancel vote
        }
    }
    return candidate;  // candidate with remaining votes is majority
}
// DRY RUN for [3,3,4,2,3,3,3]:
// cand=3,v=1 → 3:v=2 → 4:v=1 → 2:v=0 → reset:cand=3,v=1 → 3:v=2 → 3:v=3
// Result: 3 ✅

// APPROACH 2: HashMap (Simpler to understand)
public static int majorityElementMap(int[] arr) {
    Map map = new HashMap<>();
    for (int n : arr) map.put(n, map.getOrDefault(n,0)+1);
    for (Map.Entry e : map.entrySet())
        if (e.getValue() > arr.length/2) return e.getKey();
    return -1;
}

ML3 Maximum Subarray Sum (Kadane's Algorithm)▾

// Find contiguous subarray with largest sum
// [-2,1,-3,4,-1,2,1,-5,4] → 6  (subarray [4,-1,2,1])

// Kadane's Algorithm — O(n), O(1)
public static int maxSubarraySum(int[] arr) {
    int maxSum = arr[0];     // overall max seen so far
    int current = arr[0];    // current running sum
    for (int i = 1; i < arr.length; i++) {
        // either extend existing subarray OR start fresh from arr[i]
        current = Math.max(arr[i], current + arr[i]);
        maxSum = Math.max(maxSum, current); // update global max
    }
    return maxSum;
}
// DRY RUN for [-2,1,-3,4,-1,2,1,-5,4]:
// current=-2, max=-2
// i=1: max(1,-2+1=-1)=1,  max=-2→1=1
// i=2: max(-3,1-3=-2)=-2, max=1
// i=3: max(4,-2+4=2)=4,   max=4
// i=4: max(-1,4-1=3)=3,   max=4
// i=5: max(2,3+2=5)=5,    max=5
// i=6: max(1,5+1=6)=6,    max=6 ✅
// Result: 6

// Output:
// maxSubarraySum([-2,1,-3,4,-1,2,1,-5,4]) → 6
// maxSubarraySum([-1,-2,-3])              → -1

ML4 Find Repeating and Missing Number▾

// Array of 1 to N, one number repeating, one missing
// [1,2,2,4] from 1-4 → repeating=2, missing=3

public static void findRepeatMissing(int[] arr) {
    int n = arr.length;
    Map map = new HashMap<>();
    for (int x : arr) map.put(x, map.getOrDefault(x,0)+1);

    int repeating = -1, missing = -1;
    for (int i = 1; i <= n; i++) {
        int count = map.getOrDefault(i, 0);
        if (count == 2) repeating = i;   // appears twice = repeating
        if (count == 0) missing = i;     // never appears = missing
    }
    System.out.println("Repeating: " + repeating + ", Missing: " + missing);
}
// Output: findRepeatMissing([1,2,2,4]) → Repeating: 2, Missing: 3

Sorting Algorithms — Step by step with dry run on each pass

SO1 Bubble Sort▾

// Bubble Sort: repeatedly compare adjacent elements and swap if out of order.
// After each full pass, the LARGEST unsorted element "bubbles up" to its correct position.
// Time: O(n²)   Space: O(1)

public static void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {         // i = pass number (n-1 passes total)
        boolean swapped = false;                // optimization: stop early if no swaps
        for (int j = 0; j < n - 1 - i; j++) { // j goes up to (n-1-i) — last i are sorted
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];             // swap adjacent elements
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = true;
            }
        }
        if (!swapped) break;  // if no swap in this pass → already sorted, stop early
    }
}

// DRY RUN for [5, 3, 8, 1, 2]:
// Pass 1 (i=0): compare all adjacent pairs
//   [5,3] → swap → [3,5,8,1,2]
//   [5,8] → ok
//   [8,1] → swap → [3,5,1,8,2]
//   [8,2] → swap → [3,5,1,2,8]   ← 8 is in its final position ✅
// Pass 2 (i=1):
//   [3,5] → ok
//   [5,1] → swap → [3,1,5,2,8]
//   [5,2] → swap → [3,1,2,5,8]   ← 5 is in final position ✅
// Pass 3 (i=2):
//   [3,1] → swap → [1,3,2,5,8]
//   [3,2] → swap → [1,2,3,5,8]   ← 3 in final position ✅
// Pass 4 (i=3): no swaps → done!
// Result: [1,2,3,5,8] ✅

// Output: bubbleSort([5,3,8,1,2]) → [1,2,3,5,8]

SO2 Selection Sort▾

// Selection Sort: find the MINIMUM element in unsorted part, swap it to front.
// Each pass selects the correct element for position i.
// Time: O(n²)   Space: O(1)

public static void selectionSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {          // i = position we're filling
        int minIdx = i;                          // assume position i has minimum
        for (int j = i + 1; j < n; j++) {       // search rest of array for smaller
            if (arr[j] < arr[minIdx]) {
                minIdx = j;                      // found a new minimum
            }
        }
        // swap minimum to position i
        int temp = arr[minIdx];
        arr[minIdx] = arr[i];
        arr[i] = temp;
    }
}

// DRY RUN for [64, 25, 12, 22, 11]:
// i=0: search [25,12,22,11] → min=11 at idx=4 → swap arr[0]↔arr[4]
//   → [11, 25, 12, 22, 64]   ← 11 placed ✅
// i=1: search [12,22,64] → min=12 at idx=2 → swap arr[1]↔arr[2]
//   → [11, 12, 25, 22, 64]   ← 12 placed ✅
// i=2: search [22,64] → min=22 at idx=3 → swap arr[2]↔arr[3]
//   → [11, 12, 22, 25, 64]   ← 22 placed ✅
// i=3: search [64] → min=25 at idx=3 → no swap needed
//   → [11, 12, 22, 25, 64]   ✅
// Result: [11,12,22,25,64] ✅

SO3 Insertion Sort▾

// Insertion Sort: like sorting playing cards in hand.
// Pick one card at a time and INSERT it into the correct position in the sorted part.
// Time: O(n²) worst, O(n) best (already sorted)   Space: O(1)

public static void insertionSort(int[] arr) {
    int n = arr.length;
    for (int i = 1; i < n; i++) {           // start from index 1 (first element is "sorted")
        int key = arr[i];                    // pick this element to insert
        int j = i - 1;                       // j points to end of sorted portion
        // shift all sorted elements greater than key one position right
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];             // move element right
            j--;                             // move left
        }
        arr[j + 1] = key;                    // insert key at correct position
    }
}

// DRY RUN for [12, 11, 13, 5, 6]:
// i=1: key=11, arr=[12,11,13,5,6]
//   j=0: arr[0]=12 > 11 → shift: [12,12,13,5,6], j=-1
//   place key: arr[0]=11 → [11,12,13,5,6] ✅
// i=2: key=13
//   j=1: arr[1]=12 < 13 → stop
//   place key: arr[2]=13 → [11,12,13,5,6]  (no change)
// i=3: key=5
//   j=2: 13>5 shift → [11,12,13,13,6]
//   j=1: 12>5 shift → [11,12,12,13,6]
//   j=0: 11>5 shift → [11,11,12,13,6]
//   j=-1: stop. arr[0]=5 → [5,11,12,13,6] ✅
// i=4: key=6
//   j=3: 13>6 shift, j=2: 12>6 shift, j=1: 11>6 shift, j=0: 5<6 stop
//   arr[1]=6 → [5,6,11,12,13] ✅
// Result: [5,6,11,12,13] ✅

Searching Algorithms — with dry run

SE1 Linear Search▾

// Check EVERY element one by one until target found.
// Works on unsorted AND sorted arrays.
// Time: O(n)   Space: O(1)

public static int linearSearch(int[] arr, int target) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == target) return i;  // found! return index
    }
    return -1;  // not found
}

// DRY RUN for arr=[10,25,7,43,1], target=43:
// i=0: arr[0]=10 ≠ 43
// i=1: arr[1]=25 ≠ 43
// i=2: arr[2]=7  ≠ 43
// i=3: arr[3]=43 = 43 → return 3 ✅

// Output:
// linearSearch([10,25,7,43,1], 43) → 3  (found at index 3)
// linearSearch([10,25,7,43,1], 99) → -1 (not found)

SE2 Binary Search▾

// Binary Search: ONLY works on SORTED arrays.
// Each step cuts the search space in HALF → much faster than linear!
// Time: O(log n)   Space: O(1)

public static int binarySearch(int[] arr, int target) {
    int left = 0, right = arr.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2; // safe mid: avoids integer overflow
        if (arr[mid] == target) return mid;   // found at mid!
        else if (arr[mid] < target) left = mid + 1;  // target is in RIGHT half
        else                        right = mid - 1; // target is in LEFT half
    }
    return -1;  // not found
}
// WHY left + (right-left)/2 instead of (left+right)/2?
// → Prevents integer overflow when left+right exceeds Integer.MAX_VALUE

// DRY RUN for arr=[1,3,5,7,9,11,13,15], target=7:
// left=0, right=7, mid=3, arr[3]=7 == 7 → return 3 ✅

// DRY RUN for target=11:
// left=0,right=7,mid=3: arr[3]=7 < 11 → left=4
// left=4,right=7,mid=5: arr[5]=11 == 11 → return 5 ✅

// Output:
// binarySearch([1,3,5,7,9,11,13], 7)  → 3
// binarySearch([1,3,5,7,9,11,13], 99) → -1

SE3 First Occurrence in Sorted Array▾

// Sorted array may have duplicates — find FIRST (leftmost) index of target
// [1,2,2,2,3,4] target=2 → first occurrence at index 1

public static int firstOccurrence(int[] arr, int target) {
    int left = 0, right = arr.length - 1;
    int result = -1;           // store answer, start with "not found"
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) {
            result = mid;       // found a match — save it
            right = mid - 1;   // but keep searching LEFT for earlier occurrence
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return result;
}
// DRY RUN for [1,2,2,2,3,4], target=2:
// left=0,right=5,mid=2: arr[2]=2==2 → result=2, right=1
// left=0,right=1,mid=0: arr[0]=1<2 → left=1
// left=1,right=1,mid=1: arr[1]=2==2 → result=1, right=0
// left=1 > right=0 → stop
// Result: 1 ✅  (first 2 is at index 1)

SE4 Last Occurrence in Sorted Array▾

// Find LAST (rightmost) index of target
// [1,2,2,2,3,4] target=2 → last occurrence at index 3

public static int lastOccurrence(int[] arr, int target) {
    int left = 0, right = arr.length - 1;
    int result = -1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) {
            result = mid;       // found — save it
            left = mid + 1;    // keep searching RIGHT for later occurrence
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return result;
}
// DRY RUN for [1,2,2,2,3,4], target=2:
// mid=2: arr[2]=2==2 → result=2, left=3
// mid=4: arr[4]=3>2 → right=3
// mid=3: arr[3]=2==2 → result=3, left=4
// left=4>right=3 → stop
// Result: 3 ✅  (last 2 is at index 3)

Java Collections — Set, Map, List operations

Set Based

CO1 Remove Duplicates using HashSet▾

// HashSet stores UNIQUE elements only — duplicates are automatically ignored
// [1,2,2,3,3,3,4] → {1,2,3,4}

public static void removeDupsHashSet(int[] arr) {
    Set set = new LinkedHashSet<>(); // LinkedHashSet preserves insertion order
    for (int n : arr) {
        set.add(n);  // if n already exists, add() does nothing (no error)
    }
    System.out.println("After removing duplicates: " + set);
}
// ITERATION for [1,2,2,3,3,3,4]:
// add(1) → set={1}
// add(2) → set={1,2}
// add(2) → already exists, ignored!
// add(3) → set={1,2,3}
// add(3) → ignored! add(3) → ignored!
// add(4) → set={1,2,3,4} ✅

// Converting back to array:
public static int[] toDedupedArray(int[] arr) {
    return Arrays.stream(arr).distinct().toArray(); // Java 8 stream
}

// Output:
// removeDupsHashSet([1,2,2,3,3,3,4]) → [1,2,3,4]

CO2 Find Duplicate Elements using Set▾

// Use Set's property: add() returns false if element already present

public static Set findDupsSet(int[] arr) {
    Set seen = new HashSet<>();
    Set duplicates = new LinkedHashSet<>();
    for (int n : arr) {
        if (!seen.add(n)) {    // add() returns false = already in set = DUPLICATE!
            duplicates.add(n);
        }
    }
    return duplicates;
}
// ITERATION for [1,3,4,2,2,3]:
// 1 → seen={1}, dup={}
// 3 → seen={1,3}, dup={}
// 4 → seen={1,3,4}, dup={}
// 2 → seen={1,3,4,2}, dup={}
// 2 → add returns false! dup={2}
// 3 → add returns false! dup={2,3}
// Result: {2,3} ✅

Map Based

CO3 Count Frequency using HashMap▾

// Count how many times each element appears
// [a,b,a,c,b,a] → a→3, b→2, c→1

public static void countFreqMap(String[] arr) {
    Map map = new LinkedHashMap<>();
    for (String s : arr) {
        // getOrDefault: if key exists return its value, else return 0
        map.put(s, map.getOrDefault(s, 0) + 1);
    }
    for (Map.Entry e : map.entrySet()) {
        System.out.println(e.getKey() + " → " + e.getValue());
    }
}
// ITERATION for ["a","b","a","c","b","a"]:
// "a" → map={a:1}
// "b" → map={a:1, b:1}
// "a" → map={a:2, b:1}
// "c" → map={a:2, b:1, c:1}
// "b" → map={a:2, b:2, c:1}
// "a" → map={a:3, b:2, c:1} ✅

CO4 Find First Non-Repeating Character using HashMap▾

// Count frequencies using HashMap, then scan original string for count=1

public static char firstNonRepMap(String s) {
    Map map = new LinkedHashMap<>(); // LINKED preserves order!
    // Pass 1: build frequency map
    for (char c : s.toCharArray())
        map.put(c, map.getOrDefault(c, 0) + 1);
    // Pass 2: find first char with count=1
    for (char c : s.toCharArray())
        if (map.get(c) == 1) return c;
    return '_'; // all characters repeat
}
// WHY LinkedHashMap? Insertion order matters — we want the FIRST unique char.
// Regular HashMap doesn't guarantee order.

// DRY RUN for "swiss":
// map: s→3, w→1, i→1
// Scan "swiss": s→3 skip, w→1 → return 'w' ✅

// Output:
// firstNonRepMap("swiss")   → w
// firstNonRepMap("aabbcdd") → c

List Operations

CO5 Convert Array to ArrayList▾

// int[] cannot use Collections directly — must use Integer[] or Arrays.asList

// For String/Integer arrays:
String[] arr = {"Java", "Python", "C++"};

// METHOD 1: Arrays.asList (Fast, but fixed-size — cannot add/remove)
List list1 = Arrays.asList(arr);

// METHOD 2: new ArrayList (Dynamic — can add/remove freely)
List list2 = new ArrayList<>(Arrays.asList(arr));
list2.add("Go");       // ✅ works
list2.remove("C++");   // ✅ works

// METHOD 3: Stream (Java 8 — for int[] specifically)
int[] nums = {1, 2, 3, 4, 5};
List intList = Arrays.stream(nums)
                               .boxed()           // int → Integer (autoboxing)
                               .collect(Collectors.toList());

// Output:
// list2 → [Java, Python, Go]   (after add and remove)

CO6 Convert List to Set▾

// Converting List to Set automatically removes duplicates!
List list = Arrays.asList(1, 2, 2, 3, 3, 3, 4);

// HashSet — no order guaranteed
Set hashSet = new HashSet<>(list);

// LinkedHashSet — preserves insertion order (usually preferred)
Set linkedSet = new LinkedHashSet<>(list);

// TreeSet — automatically sorts elements
Set treeSet = new TreeSet<>(list);

System.out.println("Original:   " + list);       // [1,2,2,3,3,3,4]
System.out.println("LinkedSet:  " + linkedSet);  // [1,2,3,4]
System.out.println("TreeSet:    " + treeSet);    // [1,2,3,4] (sorted)

CO7 Sort a List▾

List nums = Arrays.asList(5, 2, 8, 1, 9, 3);

// METHOD 1: Collections.sort — ascending (natural order)
Collections.sort(nums);
System.out.println("Ascending: " + nums);   // [1,2,3,5,8,9]

// METHOD 2: Collections.sort with Comparator — descending
Collections.sort(nums, Collections.reverseOrder());
System.out.println("Descending: " + nums);  // [9,8,5,3,2,1]

// METHOD 3: List.sort with lambda (Java 8)
nums.sort((a, b) -> a - b);  // ascending
nums.sort((a, b) -> b - a);  // descending

// Sorting list of Strings:
List words = Arrays.asList("banana","apple","cherry");
Collections.sort(words);
System.out.println(words); // [apple, banana, cherry]

// Sorting by length:
words.sort(Comparator.comparingInt(String::length));
System.out.println(words); // [apple, banana, cherry]

CO8 Iterate HashMap▾

Map map = new LinkedHashMap<>();
map.put("Alice", 90);
map.put("Bob", 85);
map.put("Charlie", 92);

// METHOD 1: entrySet() — access both key AND value (Most common)
for (Map.Entry entry : map.entrySet()) {
    System.out.println(entry.getKey() + " → " + entry.getValue());
}

// METHOD 2: keySet() — access only keys, then get value
for (String key : map.keySet()) {
    System.out.println(key + " scored " + map.get(key));
}

// METHOD 3: values() — only values, no keys
for (int value : map.values()) {
    System.out.println(value);
}

// METHOD 4: forEach with lambda (Java 8 — cleanest)
map.forEach((key, value) -> System.out.println(key + ": " + value));

// Output (METHOD 1):
// Alice → 90
// Bob → 85
// Charlie → 92

Recursion — Every function shows call stack + dry run

RE1 Print Numbers from 1 to N▾

// Recursion idea: print N AFTER calling for N-1
// We go DEEP first (base case), then print on the way BACK UP

public static void print1toN(int n) {
    if (n == 0) return;       // BASE CASE: stop recursion when n=0
    print1toN(n - 1);         // recursive call with n-1 FIRST
    System.out.print(n + " "); // print AFTER returning from recursion
}
// WHY print AFTER the call? Because we want 1 printed before 2, 3, etc.
// The call goes deep (n=3 → 2 → 1 → 0), then prints while returning (1, 2, 3)

// CALL STACK for n=3:
// print1toN(3) → calls print1toN(2)
//   print1toN(2) → calls print1toN(1)
//     print1toN(1) → calls print1toN(0)
//       print1toN(0) → returns (base case)
//     ← prints 1
//   ← prints 2
// ← prints 3
// Output: 1 2 3 ✅

RE2 Print Numbers from N to 1▾

// Print BEFORE the recursive call → print on the way DOWN

public static void printNto1(int n) {
    if (n == 0) return;        // BASE CASE
    System.out.print(n + " "); // print FIRST (before calling)
    printNto1(n - 1);          // then recurse with n-1
}
// CALL STACK for n=3:
// printNto1(3): print 3 → calls printNto1(2)
//   printNto1(2): print 2 → calls printNto1(1)
//     printNto1(1): print 1 → calls printNto1(0)
//       printNto1(0): return (base case)
// Output: 3 2 1 ✅

// KEY DIFFERENCE from RE1:
// RE1 (1 to N): print AFTER recursive call → numbers print smallest first
// RE2 (N to 1): print BEFORE recursive call → numbers print largest first

RE3 Factorial using Recursion▾

// n! = n × (n-1)!    with base case: 0! = 1  and  1! = 1

public static long factRec(int n) {
    if (n == 0 || n == 1) return 1;   // BASE CASE: stop here
    return n * factRec(n - 1);         // RECURSIVE CASE: n × factorial(n-1)
}

// CALL STACK for n=5:
// factRec(5) = 5 × factRec(4)
//              5 × 4 × factRec(3)
//              5 × 4 × 3 × factRec(2)
//              5 × 4 × 3 × 2 × factRec(1)
//              5 × 4 × 3 × 2 × 1          ← base case returns 1
// UNWINDING the stack:
//   factRec(1) = 1
//   factRec(2) = 2×1 = 2
//   factRec(3) = 3×2 = 6
//   factRec(4) = 4×6 = 24
//   factRec(5) = 5×24 = 120 ✅

// Output: factRec(5) → 120    factRec(0) → 1

RE4 Fibonacci using Recursion▾

// fib(n) = fib(n-1) + fib(n-2)    base cases: fib(0)=0, fib(1)=1

public static int fibRec(int n) {
    if (n == 0) return 0;             // BASE CASE 1
    if (n == 1) return 1;             // BASE CASE 2
    return fibRec(n - 1) + fibRec(n - 2); // RECURSIVE CASE
}

// CALL TREE for fibRec(4):
//           fib(4)
//          /       \
//       fib(3)    fib(2)
//       /    \    /    \
//    fib(2) fib(1) fib(1) fib(0)
//    /    \
// fib(1) fib(0)
// = (1+0) + 1 + 1 + 0 = ... = 3 ✅

// ⚠️ Recursive fibonacci is O(2^n) — very slow for large n!
// Use iterative version for n > 30.

// Output:
// fibRec(0)→0  fibRec(1)→1  fibRec(5)→5  fibRec(7)→13

RE5 Check Palindrome using Recursion▾

// Compare characters from both ends, move inward recursively

public static boolean isPalinRec(String s, int left, int right) {
    if (left >= right) return true;           // BASE CASE: pointers met or crossed
    if (s.charAt(left) != s.charAt(right)) return false; // mismatch → not palindrome
    return isPalinRec(s, left + 1, right - 1); // move both pointers inward
}

// Helper method to call easily:
public static boolean isPalindrome(String s) {
    return isPalinRec(s.toLowerCase(), 0, s.length() - 1);
}

// CALL STACK for "racecar":
// isPalinRec("racecar", 0, 6): r==r ✅ → call(1,5)
//   call(1,5): a==a ✅ → call(2,4)
//     call(2,4): c==c ✅ → call(3,3)
//       call(3,3): left(3) >= right(3) → return true (BASE CASE)
//     ← returns true
//   ← returns true
// ← returns true ✅

// Output:
// isPalindrome("racecar") → true    isPalindrome("hello") → false

Pattern Programs — understand the row/column logic step by step

P1 Right Triangle Star Pattern▾

// For n=5, output:
// *
// * *
// * * *
// * * * *
// * * * * *

// Logic: Row i → print i stars (i goes from 1 to n)
public static void rightTriangle(int n) {
    for (int i = 1; i <= n; i++) {          // outer loop: each row
        for (int j = 1; j <= i; j++) {      // inner loop: print i stars
            System.out.print("* ");
        }
        System.out.println();               // move to next line after each row
    }
}

// ITERATION TABLE for n=4:
// Row i=1: j runs 1 to 1 → print 1 star  → *
// Row i=2: j runs 1 to 2 → print 2 stars → * *
// Row i=3: j runs 1 to 3 → print 3 stars → * * *
// Row i=4: j runs 1 to 4 → print 4 stars → * * * *

P2 Reverse Triangle Pattern (Inverted)▾

// For n=5, output:
// * * * * *
// * * * *
// * * *
// * *
// *

// Logic: Row i → print (n - i + 1) stars
public static void reverseTriangle(int n) {
    for (int i = n; i >= 1; i--) {          // outer loop: starts from n, goes down to 1
        for (int j = 1; j <= i; j++) {      // inner loop: print i stars
            System.out.print("* ");
        }
        System.out.println();
    }
}

// ITERATION TABLE for n=4:
// Row i=4: print 4 stars → * * * *
// Row i=3: print 3 stars → * * *
// Row i=2: print 2 stars → * *
// Row i=1: print 1 star  → *

P3 Pyramid Star Pattern▾

// For n=4, output:
//    *
//   * *
//  * * *
// * * * *
// (spaces before stars to center them)

// Logic: Each row i has (n-i) spaces then i stars
public static void pyramid(int n) {
    for (int i = 1; i <= n; i++) {
        // print leading spaces: (n-i) spaces for row i
        for (int j = 1; j <= n - i; j++) {
            System.out.print(" ");
        }
        // print stars: i stars for row i
        for (int j = 1; j <= i; j++) {
            System.out.print("* ");
        }
        System.out.println();
    }
}

// ITERATION TABLE for n=4:
// i=1: 3 spaces, 1 star  →    *
// i=2: 2 spaces, 2 stars →   * *
// i=3: 1 space,  3 stars →  * * *
// i=4: 0 spaces, 4 stars → * * * *

P4 Number Pyramid▾

// For n=4, output:
// 1
// 1 2
// 1 2 3
// 1 2 3 4

// Logic: In row i, print numbers 1 through i
public static void numberPyramid(int n) {
    for (int i = 1; i <= n; i++) {          // outer loop: each row
        for (int j = 1; j <= i; j++) {      // inner loop: print 1 to i
            System.out.print(j + " ");
        }
        System.out.println();
    }
}

// ITERATION TABLE for n=4:
// i=1: j=1       → 1
// i=2: j=1,2     → 1 2
// i=3: j=1,2,3   → 1 2 3
// i=4: j=1,2,3,4 → 1 2 3 4

// BONUS — Floyd's Triangle (continuous numbers):
// 1
// 2 3
// 4 5 6
public static void floydsTriangle(int n) {
    int num = 1;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= i; j++) System.out.print(num++ + " ");
        System.out.println();
    }
}

📋 Manual Testing Interview Questions

Fresher Level · 25 Questions from PDF · TCS, Wipro, Infosys, Amazon

Q1What is Software Testing? Give 2 definitions and explain WHY we do it.▾

Definition 1: The process of finding defects in software is called Software Testing.
Definition 2: Verifying the functionality (behaviour) of an application against requirement specification is called Software Testing.
Definition 3: Execution of a program with the intent of finding defects.

WHY we do Software Testing:
✅ To improve the quality of the product
✅ To make sure software works and meets customer expectations
✅ To find defects before customers do
✅ Every software supports a business — a defect affects the business. Before using it in business, all problems must be found and fixed.

Always give 2 definitions + 3-4 WHY points. This structured answer shows interview maturity!

CONCEPTIMPORTANTTCSWiproInfosys

Q2What are the types of Software Testing? Explain White Box, Black Box and Grey Box.▾

White Box Testing (WBT): Testing each and every line of code. Internal structure visible to tester. Done by developers.

Black Box Testing (BBT): Verifying the functionality (behaviour) of an application against requirement specification. Tester does NOT see internal code.

Grey Box Testing (GBT): Combination of WBT and BBT. Test cases designed based on knowledge of both requirements AND internal design of the code.

WBT Types:
• Path Testing: Write flowgraph, test all independent paths
• Condition Testing: Test all logical conditions for true and false values
• Loop Testing: Test all loop cycles, check for break conditions
• Memory Point of View: Check for optimal logic, avoid repeated code, use built-in functions

BBT = testing as a user (requirement-based). WBT = testing the code internally. GBT = both combined.

CONCEPTIMPORTANTTCSInfosysWipro

Q3What are the characteristics of a Good Test Engineer?▾

✅ Should have a "test to break" attitude — always try to find what can go wrong
✅ Able to see the product from 4 points of view: Customer, Business, End User, and Developer
✅ Should have very good domain knowledge — understand the business area (banking, e-commerce, healthcare etc.)
✅ Should have good technology knowledge to come up with better shortcuts to do testing efficiently

The "4 points of view" answer is unique and impresses interviewers — most freshers only say "customer perspective"!

CONCEPTIMPORTANTTCSWipro

Q4What is the difference between QA and QC?▾

Quality Assurance (QA):
• Process oriented
• Stages: Identify need → Define process → Make sure people follow → Find mistakes → Improve process
• Focuses on PREVENTING defects

Quality Control (QC):
• Product oriented
• Verifying the functionality of software against requirement specification
• Focuses on FINDING defects

Simple memory trick:
QA = Are we doing the RIGHT process? (prevention)
QC = Is the product built RIGHT? (detection)

QA and Testing are NOT the same! QA is the broader process. Testing is part of QC. Very common confusion!

TRAPIMPORTANTTCSWipro

Q5What is Black Box Testing? What are its types?▾

BBT: Verifying the functionality (behaviour) of an application against requirement specification WITHOUT knowing the internal code.

Types:
1. Functionality Testing: Testing each and every component thoroughly against requirement specification.
2. Integration Testing: Testing the data flow or the interface between the modules.
3. System Testing: End-to-end testing where testing environment is similar to production environment.

From BBT context — Unit Testing means testing each COMPONENT. From WBT context — Unit Testing means testing each LINE OF CODE. This distinction is a frequent interview trap!

TRAPIMPORTANTTCSInfosys

Q6What is Integration Testing? Types? What is Stub and Driver?▾

Integration Testing: Testing the data flow or the interface between the modules.

How to do IT:
1. Understand the application (how each module works + how modules are related)
2. Identify all possible scenarios
3. Prioritize the scenarios
4. Document the scenarios
5. Execute according to priority
6. Send bugs to development team

Types:
Incremental IT: Incrementally adding modules and testing data flow between them.
→ Top Down: Module added must be CHILD of previous module
→ Bottom Up: Module added must be PARENT of previous module
Non-Incremental IT: Combine ALL modules at once and test data flow.

Stub: A dummy module built to act like a real module — can generate or receive data. Used when dependent module is NOT ready yet.
Driver: Sets up test environment, does the transaction, analyses result and sends report.

One module ready, other NOT ready? → Create a STUB (dummy module) and do integration testing! This is the real-world answer.

TRAPIMPORTANTTCSWiproInfosys

Q7What is System Testing? Types? Difference between System Testing and End-to-End Testing?▾

System Testing: End-to-end testing where testing environment is similar to production environment.

Types: End to End, Compatibility, Performance, Usability, Accessibility, Adhoc Testing

System Testing vs E2E Testing:
System Testing: Broader. Involves multiple types (E2E, compatibility, performance, regression). Environment = production-like.
End-to-End Testing: Navigating through all features to verify the end feature works. It is a TYPE of System Testing.

System Integration Testing: Testing data flow between two DIFFERENT software systems.
Example: Instagram–Facebook, WhatsApp–Google Maps

E2E is a SUBSET of System Testing. System Testing is the umbrella term!

CONCEPTIMPORTANTTCSAmazon

Q8What is Build, Patch, Test Cycle, Release and Continuous Integration?▾

Build: All programs compiled → get binaries → binaries compressed → that compressed file = Build.

Patch: A small software containing modifying programs, newly added programs and record of deleted programs.

Test Cycle: Time/effort to start and finish complete production testing. Depends on: size, complexity, number of engineers.

Release: Gathering requirements → develop → test → launch to production = one Release.
• Traditional: 1 release = 40–60 test cycles
• Agile: 1 release = 4–7 cycles

Continuous Integration: Tools automatically create a patch and send it to the testing server. If build engineer updates, it automatically sends and installs the build. Testing can be scheduled automatically.

Who is involved in releasing? Project Manager, Development Team, Release Engineer, Test Engineer, Business Analyst

These 5 definitions come up very frequently in Wipro, TCS interviews. Memorize all of them!

CONCEPTIMPORTANTTCSWipro

Q9What is Acceptance Testing? Why do we do it? What are its 4 approaches?▾

Acceptance Testing: End-to-end testing done at customer's place using all real-time business scenarios to check whether software can handle them.

WHY:
✅ Under business pressure, software company might push software with many bugs
✅ Developers might have misunderstood requirement and built wrong feature
✅ Moving product to production with critical bugs causes severe business loss

4 Approaches:
1. TE tests software according to customer requirement from business point of view
2. UAT: End-to-end testing done by END USERS for a specific period
3. TE at customer place using user scenarios given by customer
4. TE at own place using user scenarios given by customer

Alpha Testing: Testing after build completion BEFORE releasing to production
Beta Testing: Testing AFTER releasing build to production

Alpha = before launch (internal). Beta = after launch (real users). Very common interview question!

TRAPIMPORTANTTCSWiproInfosys

Q10What is Smoke Testing? Why and when do we do it? Smoke vs Sanity?▾

Smoke Testing: Testing the basic and critical features of an application BEFORE doing thorough testing. A health check for software.

WHY:
✅ Check if product is feasible — too many early bugs = not eligible for further testing
✅ Find critical bugs early so developers have sufficient time to fix
✅ Confirm installation and configuration happened properly
✅ Check whether we received a broken build from developers

WHEN:
✅ Whenever new build arrives (developers made changes — addition, modification, removal or bug fixes)
✅ Whenever product is moved to production
✅ Customer should start acceptance testing with smoke testing

Smoke vs Sanity:
Smoke: Wide and shallow. Scripted (uses automation or manual scripts).
Sanity: Deep and narrow. Unscripted (no automation or manual script).

Smoke = broad check of entire build. Sanity = focused check after a specific fix. Wide/shallow vs Deep/narrow — very common trap question!

TRAPIMPORTANTTCSWiproAmazon

Q11What is Adhoc Testing? Why and when do we do it?▾

Adhoc Testing: Testing the application randomly WITHOUT referring to any formal documents like test cases, test scripts or test scenarios.

WHY:
✅ End customers might use application randomly and find defects — TE should find these first
✅ Requirement-based testing finds fewer bugs — creative out-of-requirement scenarios find more
✅ To break the product, increase bug count, improve test coverage
✅ To check whether product works for implicit requirements

WHEN:
✅ When feature is functionally stable
✅ Before launching to customer for acceptance testing
✅ After requirement-based testing when time remains
✅ Whenever a creative scenario comes to mind during FT, IT or ST — document it and execute when you get time

Key phrase: Adhoc testing is done WITHOUT referring to any formal documents. This is what makes it different!

CONCEPTIMPORTANTTCSInfosys

Q12What is Exploratory Testing? Drawbacks and how to overcome them?▾

Exploratory Testing: Explore the application → understand it → identify all possible scenarios → document them → do FT/IT/ST based on that understanding.

WHEN:
✅ No SRS available
✅ SRS exists but is not understandable
✅ SRS exists and is understandable but there is no time to read it

Drawbacks:
❌ Might misunderstand a feature as a bug
❌ Might misunderstand a bug as a feature
❌ A missing feature might never be discovered

How to overcome:
✅ Interact with customers, Business Analysts, Developers
✅ Compare with competing applications

Real project management:
New TE joins → explore → write test cases → test
Next new TE joins → execute existing cases (saves time) + write cases for new features

Exploratory testing is NOT random! It has structure: explore → understand → document → test. Adhoc is truly random with no documentation.

CONCEPTIMPORTANTTCSWipro

Q13What is Compatibility Testing? What kind of bugs do you find?▾

Compatibility Testing: Testing the functionality of an application in different hardware and software environments.

WHY:
✅ Developers test in one platform. End customers use different platforms and find defects → bad reputation spreads
✅ Check whether features work consistently across all platforms
✅ Developers claim common code works everywhere — we must verify

WHEN: When product is functionally stable in base platform, then test in other platforms.

Bugs found:
❌ UI/alignment issues (rendering varies H/W to H/W, OS to OS, browser to browser)
❌ Missing content, content mismatch
❌ Object overlapping
❌ Images not displayed in certain browsers
❌ Scroll bar issues (horizontal or vertical)
❌ Scattered content, broken tables/frames

For web apps: Test in different OS → different browsers → different versions → different settings (cookies enabled/disabled, different resolutions).

CONCEPTIMPORTANTTCSWipro

Q14How do you test a Web Application completely?▾

Complete approach to test a Web Application:

🔧 Functionality Testing: Test each and every component against requirement
🔗 Integration Testing: Many integration scenarios between modules
🔄 System Testing: Many end-to-end business scenarios
⚡ Performance Testing: Multiple users use it simultaneously
🖥️ Compatibility Testing: Different users use different platforms (OS, browser, version, settings: cookies/resolution)
🔒 Security Testing: If app has highly secured data/transactions
🎯 Adhoc Testing: End users might find random bugs — find them first
💨 Smoke Testing: Check basic/critical features as soon as new build arrives
🌍 Globalisation Testing: If software is delivered in multiple languages

Structured answer with ALL types shows deep knowledge. Always mention Smoke Testing at the end — "as soon as build comes"!

IMPORTANTTCSAmazonWipro

Q15What is Usability Testing? How do we do it and for what applications?▾

Usability Testing: Testing the user-friendliness of an application or the effort needed to understand the application.

HOW:
1. Take 5 new users + 5 domain experts
2. Give them the application to use
3. Users use each module and give feedback/rating
4. If rating is less than 3 → considered a bug → developers modify the UI

For which applications:
✅ Applications used by variety of users
✅ Applications used by external users
❌ Applications where users undergo training — usability testing NOT needed

WHEN:
✅ When application is functionally stable
✅ After design and development of a prototype

Rating less than 3 = bug! This specific detail impresses interviewers. Most freshers don't know this.

CONCEPTTCSWipro

Q16What is Regression Testing? Types and how to identify Impact Regions?▾

Regression Testing: Testing the UNCHANGED features to make sure they are NOT broken due to new modifications, additions, removals or bug fixes.

Types:
Unit Regression: Testing ONLY the changes or the bug which is fixed
Regional Regression: Testing the changes AND the impact regions
Full Regression: Testing the changes AND all remaining features

How to identify Impact Regions:
✅ Deep knowledge of how modules work and how they are interrelated
✅ By preparing Impact Matrix
✅ Impact Analysis Meeting (entire test team discusses every change)
✅ Interacting with customers, BA, TE, Dev Lead

Progression Testing: Testing the NEWLY ADDED feature (different from regression!)

Regression = test UNCHANGED features to ensure nothing broke. Retesting = test only the specific bug that was fixed!

TRAPIMPORTANTTCSWiproAmazon

Q17What is the difference between SDLC and STLC?▾

SDLC (Software Development Life Cycle): The procedure to DEVELOP software.
Phases: Requirement Collection → Analysis → Design → Coding → Testing → Installation → Maintenance

STLC (Software Testing Life Cycle): The procedure to TEST software.
Phases: System Study → Prepare Test Plan → Prepare Test Cases → Prepare Test Matrix → Test Execution → Defect Tracking → Test Execution Report → Retrospect Meeting

Key difference: SDLC is the entire development process. STLC is the testing portion within SDLC.

Testing in STLC starts at SYSTEM STUDY (understanding requirements) — NOT just at execution. This shows shift-left thinking!

CONCEPTIMPORTANTTCSWiproInfosys

Q18What is Performance Testing? What are its types?▾

Performance Testing: Testing the stability and response time of an application by applying load.

Key Terms:
• Response Time: Time taken to send request → execute code → return output
• Stability: Ability to withstand the number of users
• Load: Number of users

Types:
Load Testing: Load ≤ designed number of users
Stress Testing: Load > designed number of users
Volume Testing: Transferring huge amount of DATA through the software
Soak Testing: Applying CONTINUOUS load over a long period of time

Load = within limits. Stress = beyond limits. Volume = huge data. Soak = continuous over time. Memorize these 4!

CONCEPTIMPORTANTTCSWiproAmazon

Q19What is Globalization Testing — I18N and L10N?▾

I18N Testing (Internationalization): Testing an application developed for multiple languages.

What we check:
✅ Content is in right language
✅ Right content displayed in right place
✅ Feature does not break when language is changed

Types of bugs found:
❌ Selected Chinese but content displayed in French
❌ Certain content displayed in English regardless of language selected
❌ Alignment not properly assigned for every language
❌ Cursor direction wrong (English = left, Urdu = right)

Pseudo Translation: Add prefix + suffix to test if text layout breaks

L10N Testing (Localization): Testing whether features work according to country standard or culture.
Examples: Currency format (₹ vs $), PIN code format, Date format (DD/MM/YYYY vs MM/DD/YYYY)

I18N = 18 letters between I and N. L10N = 10 letters between L and N. Fun facts interviewers love!

CONCEPTTCSWipro

Q20What is Accessibility Testing? What is it also called?▾

Accessibility Testing: Testing the user-friendliness of the software from a physically challenged person's point of view.

Also known as: ADA Testing (American Disability Act) / S08 Testing

What we check:
✅ Software user friendly for disabled people?
✅ Screen reader compatibility (visually impaired)
✅ Keyboard-only navigation (motor impaired)
✅ Color contrast (color blind users)
✅ Alt text for images, Captions for videos (hearing impaired)

ADA (American Disability Act) and S08 are alternative names. Knowing the alternative names impresses interviewers!

CONCEPTTCSWipro

Q21What is a Test Case? Why do we write it? When do we write it?▾

WHY we write Test Cases:
✅ Better test coverage
✅ Consistency in test execution
✅ Avoid training every new engineer on product/requirements
✅ Depend on the PROCESS rather than the PERSON
✅ Acts as proof to customers, dev team, management that all scenarios are covered
✅ Base document for writing automation scripts — same coverage in automation
✅ Don't have to remember scenarios if documented
✅ Test execution happens in organized way, time reduces

WHEN to write:
✅ When developers are building the product
✅ When developers add new features
✅ When developers modify any feature/story (write for modified + linked features)

Procedure: System Study → Identify Scenarios → Write → Review → Fix Comments → Verify → Approve → Store in Repository

"Depend on process rather than person" — this one line shows process maturity. Very impressive in interviews!

CONCEPTIMPORTANTTCSWiproInfosys

Q22What are Test Case Design Techniques? Explain EP, BVA, Error Guessing.▾

1. Error Guessing: Guess all possible errors based on intuition and experience. No formal method — uses tester's expertise.

2. Equivalence Partitioning (EP):
• If input is range → 1 valid value + 2 invalid values
• If input is set → 1 valid + 2 invalid
• If input is boolean → test both True and False

Example (Age 18-60): test 10 (invalid below), 35 (valid), 70 (invalid above)

3. Boundary Value Analysis (BVA):
If input range is A to B, test: A-1, A, A+1, B-1, B, B+1

Example (Age 18-60): test 17, 18, 19, 59, 60, 61

4. Test Case Optimization: Reduce scenarios by removing repeated cases found by EP and BVA

EP tests WITHIN partitions. BVA tests at the BOUNDARIES. Use both together for maximum coverage with minimum test cases!

TRAPIMPORTANTTCSWiproInfosys

Q23What is a Defect? Difference between Defect, Bug, Error and Failure?▾

Defect: Deviation from requirement specification. A feature not working according to requirements.
Bug: An informal name given to a defect.
Error: A mistake done in the code because of which we cannot compile or run the program.
• Compile-time Error: Due to syntax errors
• Run-time Error: Due to logical mistakes
Failure: Defect causes or leads to failure. One defect might lead to 1 or multiple failures.

Chain: Developer makes ERROR → creates DEFECT/BUG in software → software shows FAILURE to user

Why send bug to developer immediately?
✅ Otherwise you will forget the bug
✅ Developers will have sufficient time to fix it
✅ Otherwise someone else will find it

Defect = formal term. Bug = informal. Error = code mistake preventing compilation/execution. Many testers use them interchangeably — but the distinction shows your depth!

TRAPIMPORTANTTCSWiproInfosys

Q24Explain all Defect statuses — Reject, Not Reproducible, Duplicate, Postpone, Cannot Be Fixed, RFE.▾

Rejected: TE reports as defect, but dev team says it is a FEATURE.
WHY: Misunderstanding of requirement, old requirement, improper installation, extra features.

Not Reproducible: TE sees the defect but developer cannot reproduce it.
WHY: Improper defect report, different platform (OS/browser/version), different data used.

Duplicate: Bug already sent by someone else.
WHY: Common features, old TE already found same bug.

Postpone: Developer accepts defect but wants to fix later.
WHY: Minor bug with no time to fix, feature expected to change soon, bug only in internal-user area.

Cannot Be Fixed: Developer accepts defect but says they cannot fix it.
WHY: Cost of fixing > cost of business loss; fixing core feature bug might cause bigger impact.

RFE (Request For Enhancement): Bug found is not in requirement — it is an enhancement request.

Postpone = valid bug, will be fixed later. Cannot Be Fixed = valid bug, will NEVER be fixed. These are very different statuses!

TRAPIMPORTANTTCSWiproAmazon

Q25How do you convince a developer that your finding IS a defect?▾

When developer says "Not Reproducible":

✅ Tell the exact procedure, data used and platform used to get the bug
✅ Send a screenshot of the bug
✅ Call them to your computer and give a live demo
✅ Try reproducing the bug on 4-5 computers around you and ask them to see
✅ If still not accepted — escalate to Team Lead or Manager

Always try to reproduce on multiple machines first! If bug appears on 4 machines, developer cannot deny it. Escalation is last resort.

IMPORTANTTCSWiproAmazon

Mid Level · TCS, Amazon, Swiggy

Q1What is Severity and Priority? All levels with examples.▾

Severity: Impact of defect on customer's business. Decided by TESTER.
Levels: Blocker/Show Stopper → Critical → Major → Minor

Priority: Importance to fix (how soon it should be fixed). Decided by PM/Business.
Levels: High → Medium → Low

4 Combinations:
🔴 High Severity + High Priority: App crashes on login → Fix immediately!
🟡 High Severity + Low Priority: Crash on rarely used admin report → Wait
🟠 Low Severity + High Priority: CEO name misspelled on homepage → Fix today!
🟢 Low Severity + Low Priority: Typo on Terms page → Next sprint

CEO name = Low Severity (cosmetic) but High Priority (brand/business impact). This is THE example to use in every interview!

CONCEPTIMPORTANTTCSWiproAmazon

Q2What is Defect Triage, Defect Seeding and Defect Masking?▾

Defect Triage: When time is very less and too many pending bugs exist, all relevant people sit together and GROUP bugs into categories:
• Business critical bugs → Assign status (fix immediately)
• Bugs to fix but not immediately → Postpone status
• Bugs that need not be fixed → Cannot Be Fixed status
This grouping activity = Defect Triage.

Defect Seeding: Intentionally introducing defects to test the EFFECTIVENESS of the test engineer. Like a test for the tester!

Defect Masking: When one bug is HIDING another bug.
Example: Login crash (bug 1) hides dashboard display issue (bug 2) — you can never reach dashboard to see bug 2.

Defect Triage is used in final stages before release — shows real-world project knowledge!

CONCEPTIMPORTANTAmazonWipro

Q3What is a Test Plan? What does it contain?▾

Test Plan: A document which drives all features of testing activities.

📄 Scope: What will and will NOT be tested
📄 Test Objectives: Goals of testing
📄 Test Strategy: Types of testing, approach
📄 Resources: Team, tools, environments
📄 Schedule: Timeline, milestones
📄 Entry/Exit Criteria: When to start/stop
📄 Risk and Mitigation: What can go wrong
📄 Deliverables: Test cases, reports
📄 Release Notes: What changed in this release
📄 Matrices: Test coverage metrics
📄 Effort Estimation: How long each task takes

Entry Criteria: Requirements finalized, environment ready, smoke passed
Exit Criteria: 95% cases executed, 0 critical bugs open, customer sign-off

Entry and Exit criteria are the most forgotten parts. Always mention them explicitly!

CONCEPTIMPORTANTTCSWipro

Q4What is a Traceability Matrix? Types — Forward, Backward, Bidirectional?▾

Traceability Matrix: A document written to ensure that every requirement has at least one test case. Maps requirements to test cases.

Types:
Forward Traceability: Requirement → Test Case (ensures all requirements are tested)
Backward Traceability: Test Case → Requirement (ensures no unnecessary test cases)
Bidirectional: Both directions together

Advantages:
✅ No requirement missed, no unnecessary test cases, easy to identify impact on requirement change, proof everything was tested

Disadvantages:
❌ Time consuming to maintain, needs constant update when requirements change

When no requirement is given → build traceability matrix based on your understanding of the application (exploratory approach)!

CONCEPTIMPORTANTTCSWipro

Q5Why go for Automation? What are drawbacks of Manual Testing?▾

Drawbacks of Manual Testing (reasons to automate):
❌ Repeatedly testing the same feature is tedious and error-prone
❌ TE might not be effective over a period of time (boredom, fatigue)
❌ As product size increases, test cycle duration increases
❌ Increased test cycle = increased turnaround time for customer delivery
❌ Manpower is expensive

Frame it as: Manual testing limitations DRIVE the need for automation — not that manual testing is bad! Manual always has its place.

CONCEPTIMPORTANTTCSWiproAmazon

Senior Level · Agile + Strategy · Amazon, Swiggy

Q1What is Scrum? Explain Daily Standup, Story Points, Burn Down Chart, Product Backlog.▾

Scrum: A framework to manage the complete product development process.

Daily Standup (Scrum Meeting):
• Entire Scrum team meets daily
• Each engineer presents: What I did yesterday + What I plan today + Impediments
• Led by Scrum Master (10-15 mins at start of day)
• Scrum Master notes impediments in Impediment Backlog

Story Point: Estimated effort to develop AND test a feature/story.

Burn Down Chart: Graphical representation of work expected vs time. Shows remaining work vs sprint timeline.

Product Backlog: Prioritized list of features/stories to be developed. Very high-level. Managed by Product Owner.

Sprint Backlog: Features selected from Product Backlog to complete in current sprint.

Story Board: Shows list of pending tasks + completed tasks (To Do / In Progress / Done).

Story Point = effort to develop AND test. Not just develop. This shows QA thinking in Agile — very impressive!

CONCEPTIMPORTANTAmazonSwiggyTCS

Q2How do you build a QA strategy from scratch for a new product?▾

Step 1: Understand the product — What does it do? Who are users? What is the business risk?
Step 2: Define testing scope — Functional, API, performance, security, mobile?
Step 3: Build test pyramid — 70% unit (devs own), 20% API/integration, 10% E2E
Step 4: Automation strategy — Framework, what to automate first (regression + smoke)
Step 5: CI/CD integration — Tests run on every PR. No merge without passing tests.
Step 6: Definition of Done — Story not done until tested
Step 7: Metrics and reporting — Dashboard for exec, daily status for team

Shift-left, CI/CD, quality gates — these show you think about quality as a CULTURE, not just a testing phase!

IMPORTANTAmazonSwiggy

🤖 Selenium + Java Questions

Fresher Level · Asked in TCS, Wipro, Amazon

Q1What are the different Locators in Selenium? Which is best?▾

Best to worst order:
1. ID — fastest, most reliable. Always use if available.
2. Name — good, usually unique
3. CSS Selector — fast, flexible, widely used
4. XPath — most powerful, traverses DOM, slightly slower
5. Class Name — avoid if multiple elements share same class
6. Tag Name — too generic
7. Link Text — anchor tags only
8. Partial Link Text — partial match on anchors

driver.findElement(By.id("loginBtn")); driver.findElement(By.cssSelector("button.login-btn")); driver.findElement(By.xpath("//button[@type='submit']"));

Never use absolute XPath like /html/body/div[1]/button — breaks on smallest UI change!

CONCEPTIMPORTANTTCSWipro

Q2What are the types of Waits in Selenium? Which to use?▾

Thread.sleep(): Hard wait. Fixed time. BAD practice — wastes time.
Implicit Wait: Global for all findElement calls. Set once. Not recommended.
Explicit Wait: Specific condition on specific element. BEST approach!
Fluent Wait: Like explicit but with polling interval + ignoring exceptions.

// Explicit Wait — BEST PRACTICE WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10)); WebElement el = wait.until( ExpectedConditions.visibilityOfElementLocated(By.id("result")) );

NEVER mix Implicit and Explicit wait — causes unpredictable cumulative wait times!

TRAPIMPORTANTTCSAmazon

Q3Explain Page Object Model (POM). Why do we use it?▾

POM: Each web page has a corresponding Java class. All locators and interactions in that class. Tests only call methods from page classes.

✅ Reusability, ✅ Maintainability, ✅ Readability, ✅ Separation of concerns

public class LoginPage { By email = By.id("email"); By loginBtn = By.id("loginBtn"); public void login(String e, String p) { driver.findElement(email).sendKeys(e); driver.findElement(loginBtn).click(); } } // In test: loginPage.login("user@test.com", "pass");

CONCEPTIMPORTANTTCSAmazon

Mid Level

Q1How do you handle StaleElementReferenceException?▾

Cause: DOM refreshed after element was found. Reference became 'stale'.

// Solution: Re-find with retry public void clickSafely(By locator) { int attempts = 0; while(attempts < 3) { try { driver.findElement(locator).click(); break; } catch(StaleElementReferenceException e) { attempts++; } } }

Use ExpectedConditions.refreshed() in Selenium 4 — purpose-built for stale element handling!

TRAPAmazonTCS

Senior Level

Q1How do you ensure Selenium tests are stable and not flaky?▾

Root causes and fixes:
🔴 Timing issues → Explicit waits, never Thread.sleep()
🔴 Test data dependency → Each test creates own data, cleans up after
🔴 Test order dependency → Tests must be independent, any order
🔴 Environment issues → Docker for consistent environments
🔴 Dynamic elements → Robust locators, handle StaleElementException

Detection: Run tests 3x — if results differ, it's flaky
Quarantine: Move flaky tests to separate suite until fixed

Quarantine strategy is key — don't let flaky tests block CI pipeline!

IMPORTANTAmazonSwiggy

🔗 API Testing Questions

Fresher Level · Asked in TCS, Wipro, Amazon, Swiggy

Q1What is REST API? Explain GET, POST, PUT, PATCH, DELETE.▾

REST: Architectural style for APIs using HTTP. Stateless, resource-based.

GET: Retrieve data. No body. Idempotent. Safe.
POST: Create new resource. Has body. NOT idempotent.
PUT: Replace ENTIRE resource. Idempotent.
PATCH: Update PARTIAL resource.
DELETE: Delete a resource. Idempotent.

Idempotent = same request multiple times gives same result. GET, PUT, DELETE = idempotent. POST = NOT! Calling POST twice creates two resources!

TRAPIMPORTANTTCSAmazon

Q2What are HTTP Status Codes? Explain the most important ones.▾

2xx Success: 200 OK, 201 Created, 204 No Content
3xx Redirect: 301 Moved Permanently, 304 Not Modified
4xx Client Error: 400 Bad Request, 401 Unauthorized, 403 Forbidden, 404 Not Found, 422 Unprocessable, 429 Rate Limited
5xx Server Error: 500 Internal Error, 502 Bad Gateway, 503 Unavailable

401 vs 403: 401 = Not logged in. 403 = Logged in but no permission. Very common interview question!

TRAPIMPORTANTTCSAmazonSwiggy

Q3Write a Rest Assured test to verify a GET API response.▾

import static io.restassured.RestAssured.*; import static org.hamcrest.Matchers.*; @Test public void testGetUser() { given() .baseUri("https://api.example.com") .header("Authorization", "Bearer " + token) .when() .get("/users/1") .then() .statusCode(200) .body("name", equalTo("John Doe")) .body("email", containsString("@")) .body("id", notNullValue()) .time(lessThan(2000L)); // response time check! }

Always verify response TIME! Shows you test performance too, not just functionality!

IMPORTANTAmazonTCS

Mid Level

Q1How do you test API security? What vulnerabilities do you check?▾

Based on OWASP API Security Top 10:
🔐 IDOR: User A accesses User B's data by changing ID → /users/1 → /users/2
🔐 Auth: Test without token (401), expired token (401), brute force
🔐 Data Exposure: Response should NOT return passwords, SSNs, card numbers
🔐 Rate Limiting: 1000 requests → should get 429
🔐 Injection: SQL/NoSQL injection in params
🔐 HTTPS: HTTP requests should be rejected

Mention OWASP API Security Top 10 by name — shows senior knowledge!

IMPORTANTAmazonSwiggy

Senior Level

Q1What is API contract testing? How is it different from functional testing?▾

Functional Testing: Tests that API returns correct data for specific inputs. Tests behavior.
Contract Testing: Tests that API conforms to its specification (OpenAPI/Swagger). Tests structure.

In microservices — if Team A removes a field, Team B's service breaks! Contract testing catches this early.
Tools: Pact (consumer-driven), Dredd, Postman schema validation

Mention Pact for consumer-driven contract testing — very popular in modern tech companies!

IMPORTANTAmazonSwiggy

📄 ATS Resume Builder

Build a free ATS-friendly resume in minutes · 5 Premium Templates · Download as PDF

🎨 Choose Your Template

All templates are ATS-safe & recruiter approved

📄 How do you want to start?

🤖 AI Resume Reader

👉 Open your old resume PDF → Select All (Ctrl+A) → Copy (Ctrl+C) → Paste below

Paste your existing resume text here:

              🔒 Your data stays on your device. Nothing is saved.
            

👤 Personal Information

Full Name * Job Title / Role *

Phone

GitHub / Portfolio

Location

Years of Experience

📝 Professional Summary

Write 2-3 impactful lines about yourself

⚡ Technical Skills

Add skills separated by commas Soft Skills (optional)

💼 Work Experience

🎓 Education

🚀 Projects

🏆 Certifications

Add certifications separated by commas

🌐 Languages

Languages you speak (optional)

👁️ Live Preview

📄

Your Resume Preview

Fill the form on the left to see your resume live here

✅ ATS Score Tips

✅ Match keywords from job description
✅ Keep to 1 page (fresher) / 2 pages (senior)
✅ Use action verbs: Developed, Automated, Led
✅ Add metrics: Reduced bugs by 30%
✅ Avoid images, columns, tables in ATS
✅ Standard headings: Experience, Education
✅ Save as PDF — never .docx for ATS

🏢 Template Guide

📋 ATS Classic — TCS, Infosys, Wipro, Amazon
💼 Executive — FAANG, Product companies
🎓 Fresher Blue — Campus, Internships
⚡ Creative Tech — Startups, Fintech, SaaS
🏛️ Consulting — Senior / Leadership roles

🗺️ DevOps Roadmap — Fresher to 5 Years Experience

Follow this path step by step · Green = Must Know · Blue = Good to Know · Purple = Advanced

🎯 Phase 0 — Foundation (Weeks 1-6)

Before learning DevOps tools, you MUST be strong in these fundamentals. Every DevOps engineer uses these daily.

🐧 Linux Basics

File system: ls, cd, mkdir, rm, cp, mv
File permissions: chmod, chown
Processes: ps, top, kill, systemctl
Text tools: grep, awk, sed, tail -f
Networking: ssh, curl, ping, netstat
Shell scripting: variables, loops, if/else

🌐 Networking Basics

What is IP address, DNS, HTTP/HTTPS
TCP vs UDP — when to use which
Common ports: 80, 443, 22, 3306, 5432
Firewall and load balancer concept
OSI model (7 layers) basics

💬 Scripting

Bash scripts for automation
Python basics — very useful in DevOps
Write a script to backup files
Write a script to check disk usage
Automate server health checks

⏱️ 4-6 weeks · 🎯 Start here — no shortcuts!

🔀 Phase 1 — Git & Version Control (Weeks 6-8)

Every single DevOps pipeline starts with a git push. You must know Git inside out.

🔀 Git Essentials

init, clone, add, commit, push, pull
Branching: branch, checkout, merge
Resolving merge conflicts
git stash, revert, reset
Pull Requests and code review
.gitignore best practices

🌿 Branching Strategies

GitFlow — enterprise standard
Feature branching — most common
Trunk Based — modern CI/CD teams
Branch naming conventions
Commit message standards

🐙 Platforms

GitHub — most popular
GitLab — built-in CI/CD
Webhooks to trigger pipelines
GitHub Actions basics

⏱️ 1-2 weeks · 📌 Practice daily commits on real projects

🐳 Phase 2 — Docker & Containers (Months 2-3)

Docker is the #1 skill interviewers ask about. Master it completely before moving to Kubernetes.

🐳 Docker Core

Container vs VM — understand deeply
Write Dockerfiles from scratch
docker build, run, ps, stop, rm, logs
docker exec -it container bash
Volumes for persistent storage
Docker networking — bridge, host

📦 Docker Compose

docker-compose.yml syntax
Multi-container apps (app + DB)
docker-compose up/down/logs
Environment variables in compose
Depends_on and health checks

📋 Best Practices

Multi-stage builds (smaller images)
Non-root user in containers
Image scanning with Trivy
Push to Docker Hub / AWS ECR

⏱️ 2-3 weeks · 🚀 Build and containerize a real Java/Python app

🔄 Phase 3 — CI/CD Pipeline (Months 3-5)

This is the HEART of DevOps. Automate the entire path from code to production.

🔧 Jenkins

Install Jenkins on Linux
Declarative pipeline (Jenkinsfile)
Build triggers and webhooks
Integrate with Git, Docker, Slack
Jenkins agents and distributed builds
Credentials and secrets management

⚡ GitHub Actions

Workflow YAML syntax
Triggers: push, PR, schedule
Jobs, steps, runners
Marketplace actions
Secrets and environment vars

🔍 Code Quality

SonarQube — code analysis
Unit test integration in pipeline
Code coverage reports
Fail pipeline on quality gate

⏱️ 3-4 weeks · 🏆 Build end-to-end: git push → build → test → Docker → deploy

☁️ Phase 4 — Cloud Platform (Months 5-8)

90% of companies use AWS. Learn AWS first. Azure/GCP after.

☁️ AWS Core Services

EC2 — create and manage VMs
S3 — store files, logs, artifacts
IAM — users, roles, policies
VPC — subnets, security groups, NACL
ELB — load balancing across EC2
Auto Scaling groups
CloudWatch — logs and alarms

🎓 AWS Certification

AWS Solutions Architect Associate
AWS DevOps Professional (advanced)
Highly valued by Indian IT companies
Adds ₹2-5 LPA to your salary!

🔵 Other Clouds

Azure (strong in banking/finance)
GCP (AI/ML workloads)
Learn one deeply first

⏱️ 4-6 weeks · 🎯 Hands-on: Create VPC, EC2, S3, set up auto scaling

🏗️ Phase 5 — Infrastructure as Code (Months 8-10)

Stop clicking in AWS console. Manage everything as code. This separates good DevOps engineers from great ones.

🏗️ Terraform

HCL syntax: resources, variables, outputs
Provider configuration (AWS)
terraform init / plan / apply / destroy
State management with S3 backend
DynamoDB state locking for teams
Modules for reusable infra code
Workspaces for dev/staging/prod

📋 Ansible

Inventory files and host groups
Playbooks with tasks and handlers
Variables, templates (Jinja2)
Ansible Roles for reusability
Ansible with AWS dynamic inventory
Idempotent playbook design

🔄 GitOps IaC

Store all IaC in Git
PR review for infra changes
Terraform Cloud for teams
Atlantis for automated plan/apply

⏱️ 3-4 weeks · 🏆 Create entire AWS environment using only Terraform code

☸️ Phase 6 — Kubernetes (Months 10-14)

K8s is the most in-demand skill in DevOps right now. Takes time to master but huge salary jump.

☸️ K8s Fundamentals

Architecture: master + worker nodes
Pods, ReplicaSets, Deployments
Services: ClusterIP, NodePort, LB
ConfigMaps and Secrets
Namespaces for isolation
All kubectl commands
Liveness and Readiness probes

📈 K8s Advanced

HPA — auto scaling by CPU/memory
Ingress controllers (nginx)
Persistent Volumes and PVCs
RBAC — role based access control
Rolling updates and rollbacks
Helm charts for packaging
AWS EKS managed Kubernetes

🔄 GitOps with K8s

ArgoCD for auto deployment
FluxCD alternative
Sync Git → K8s automatically
Rollback via Git revert

⏱️ 4-6 weeks · 🚀 Deploy a microservices app on EKS with auto scaling

📊 Phase 7 — Monitoring & Security (Months 14-17)

Production is live. Now you need to KNOW what is happening at all times and keep it secure.

📊 Monitoring Stack

Prometheus — metrics collection
Grafana — dashboards and alerts
AlertManager — route alerts to Slack
ELK stack — centralized logging
Distributed tracing — Jaeger/Zipkin
SLA, SLO, SLI definitions

🔒 DevSecOps

SonarQube — code security scan
Trivy — Docker image scanning
HashiCorp Vault — secrets management
OWASP Top 10 awareness
Network policies in Kubernetes
Least privilege IAM policies

💰 Cost Optimization

AWS Cost Explorer usage
Right-sizing EC2 instances
Spot instances for non-critical
Reserved instances for steady loads

⏱️ 3-4 weeks · 🎯 Set up full Prometheus + Grafana stack with alerts

🚀 Phase 8 — Senior Level (17+ months)

At this level you design systems, lead teams, and drive architecture decisions.

🏛️ Platform Engineering

Build Internal Developer Platforms
Self-service infrastructure portals
Backstage developer portal
Developer experience (DX) focus

💸 FinOps

Cloud cost governance
Multi-account AWS strategies
Cost allocation tagging
Budget alerts and policies

🤖 AI/ML Ops

MLflow for model tracking
Kubeflow pipelines
GPU cluster management
Model deployment automation

⏱️ Ongoing learning · 💼 Expected CTC: ₹20-40 LPA

Legend: ✅ Must Know 💡 Good to Know 🚀 Advanced

Feature	Docker Container	Virtual Machine
Size	MBs	GBs
Startup Time	Seconds	Minutes
OS	Shares host OS kernel	Full OS inside
Performance	Near native	10-20% overhead
Isolation	Process level	Full hardware level

Feature	Ansible	Terraform
Category	Configuration Management	Infrastructure Provisioning
What it manages	Software on existing servers	Creates cloud resources
Language	YAML (Playbooks)	HCL (HashiCorp)
Agent on server?	No — uses SSH	No
Real example	Install Java, configure nginx	Create EC2, VPC, RDS on AWS

🏭 Scenarios

🎯 Manual Testing – Real-Time Scenarios

1Login Page Testing▾

🎯 Scenario Question:

You are assigned to test a login page. What scenarios will you cover?

📋 Key Testing Points:

Valid login
Invalid credentials
Empty fields
Boundary values on inputs
Password masking
Security — no SQL injection

🎤 Ready-to-Say Interview Answer:

“While testing a login page, I first verify that the user can log in successfully with valid credentials. Then I test negative scenarios such as incorrect username or password, and empty fields, to confirm proper validation messages are shown. I also check boundary values on input lengths and verify the password field is always masked.”

2Registration Page Testing▾

🎯 Scenario Question:

How would you test a user registration page?

📋 Key Testing Points:

Valid registration
Duplicate email check
Mandatory field validation
Email format
Password strength rules

🎤 Ready-to-Say Interview Answer:

“I verify that a user can register with valid details. I test duplicate email submission to ensure the system rejects it. I check mandatory field validation, email format, and password strength rules like minimum length.”

3Forgot Password Testing▾

🎯 Scenario Question:

How would you test the forgot password functionality?

📋 Key Testing Points:

Registered email gets reset link
Unregistered email shows error
Link expiry
Password update works

🎤 Ready-to-Say Interview Answer:

“I verify a reset link is sent to a registered email. I test with an unregistered email to confirm an appropriate message is shown. I also check the link expires after the defined time and the user can set a new password.”

4Logout Functionality▾

🎯 Scenario Question:

How would you test logout functionality?

📋 Key Testing Points:

Logout button works
Session ends
Back button cannot access secured pages

🎤 Ready-to-Say Interview Answer:

“I verify clicking logout ends the session and redirects to the login page. I press the browser back button to confirm the user cannot re-enter secured pages without logging in again.”

5Search Functionality Testing▾

🎯 Scenario Question:

How would you test search functionality?

📋 Key Testing Points:

Valid keyword returns results
Partial keyword works
Special characters handled
No-results message shown

🎤 Ready-to-Say Interview Answer:

“I verify that valid keyword searches return accurate results. I test partial keywords and special characters to confirm the system handles them without errors. I also check that a clear message appears when no results are found.”

6UI Testing Scenario▾

🎯 Scenario Question:

What UI elements do you check while testing?

📋 Key Testing Points:

Alignment
Font and color consistency
Button visibility
Responsiveness on different screen sizes

🎤 Ready-to-Say Interview Answer:

“I verify that all components like buttons, input fields, and images are properly aligned. I check fonts and colors match the design. I also test responsiveness across mobile, tablet, and desktop screen sizes.”

7File Upload Testing▾

🎯 Scenario Question:

How would you test file upload functionality?

📋 Key Testing Points:

Valid file uploads successfully
Invalid format rejected
File size limit enforced
Success confirmation shown

🎤 Ready-to-Say Interview Answer:

“I verify a supported file type uploads and a confirmation message is displayed. I test invalid formats and files above the size limit to ensure the system rejects them with a clear error message.”

8Payment Gateway Testing▾

🎯 Scenario Question:

How would you test a payment gateway?

📋 Key Testing Points:

Successful payment
Invalid CVV/expired card rejected
Insufficient balance handled
Network failure scenario

🎤 Ready-to-Say Interview Answer:

“I verify the full payment flow with valid card details. I test invalid CVV, expired card, and insufficient balance. I also simulate a network interruption to verify the system does not double-charge and handles failure gracefully.”

9Session Timeout Testing▾

🎯 Scenario Question:

How would you test session timeout functionality?

📋 Key Testing Points:

Idle session triggers auto-logout
User redirected to login
Session data cleared

🎤 Ready-to-Say Interview Answer:

“I stay idle beyond the configured timeout period after logging in. I verify the system automatically logs out the user and redirects to the login page with no session data remaining.”

10Form Validation Testing▾

🎯 Scenario Question:

How do you test form validations?

📋 Key Testing Points:

Mandatory fields cannot be empty
Input format validated — email, phone
Correct error messages at right location

🎤 Ready-to-Say Interview Answer:

“I leave mandatory fields empty and submit the form, verifying proper validation messages appear next to each field. I also test email and phone number format validation.”

11Dropdown Testing▾

🎯 Scenario Question:

How would you test a dropdown list?

📋 Key Testing Points:

All options display correctly
Selection works
Default value is correct
Dependent dropdowns update

🎤 Ready-to-Say Interview Answer:

“I verify all dropdown options display in the correct order. I select each option and confirm the system responds as expected. For dependent dropdowns, I check selecting one updates the other correctly.”

12Pagination Testing▾

🎯 Scenario Question:

How do you test pagination?

📋 Key Testing Points:

Next/Previous buttons work
Correct records per page
First/Last page boundary handled

🎤 Ready-to-Say Interview Answer:

“I verify Next and Previous buttons navigate correctly. I check the correct number of records appears per page, and boundary buttons are disabled correctly on the first and last pages.”

13Error Message Testing▾

🎯 Scenario Question:

How do you validate error messages?

📋 Key Testing Points:

Message is clear and user-friendly
Displayed near the relevant field
No technical details exposed

🎤 Ready-to-Say Interview Answer:

“I verify error messages appear next to the relevant field in clear, simple language. I also check that no system-level technical details are exposed to the user.”

14Broken Link Testing▾

🎯 Scenario Question:

How would you test for broken links?

📋 Key Testing Points:

All links redirect correctly
No 404 errors
External links open in new tab

🎤 Ready-to-Say Interview Answer:

“I click every link in the application and verify it redirects correctly. I check for 404 errors and confirm external links open in a new tab.”

15Browser Compatibility Testing▾

🎯 Scenario Question:

How do you test browser compatibility?

📋 Key Testing Points:

Tested on Chrome, Firefox, Edge, Safari
UI consistent
All features work across browsers

🎤 Ready-to-Say Interview Answer:

“I open the application in Chrome, Firefox, Edge, and Safari. I verify the UI looks consistent and all features work correctly across each browser.”

16Mandatory Field Testing▾

🎯 Scenario Question:

How would you test mandatory fields?

📋 Key Testing Points:

Submit form with empty required fields
Validation messages shown
Fields marked clearly

🎤 Ready-to-Say Interview Answer:

“I submit the form with all mandatory fields empty and verify the system shows appropriate validation messages. I confirm mandatory fields are clearly marked.”

17Navigation Menu Testing▾

🎯 Scenario Question:

How would you test a navigation menu?

📋 Key Testing Points:

All menu links work
Correct page loads
Active state highlights current page

🎤 Ready-to-Say Interview Answer:

“I click each menu item and confirm it loads the correct page. I verify the active state is highlighted and no links are broken.”

18Data Save Verification▾

🎯 Scenario Question:

How would you verify that data is saved correctly?

📋 Key Testing Points:

Submit form
Saved data visible in the system
Data matches what was entered

🎤 Ready-to-Say Interview Answer:

“After submitting a form, I navigate to the data display area and verify all entered information is saved accurately and matches the input.”

19Duplicate Data Testing▾

🎯 Scenario Question:

How do you test duplicate data prevention?

📋 Key Testing Points:

Try creating two records with same unique key
System rejects with clear message

🎤 Ready-to-Say Interview Answer:

“I create a record then attempt to create another with the same unique identifier. I verify the system prevents it and shows a meaningful error message.”

20Search Filter Testing▾

🎯 Scenario Question:

How do you test search filters?

📋 Key Testing Points:

Apply each filter individually
Combine multiple filters
Results match the selected criteria

🎤 Ready-to-Say Interview Answer:

“I apply each filter one by one and verify results match the criteria. I also combine multiple filters and confirm results narrow down correctly.”

21Sorting Feature Testing▾

🎯 Scenario Question:

How do you test sorting functionality?

📋 Key Testing Points:

Ascending sort for each column
Descending sort
Data order is accurate

🎤 Ready-to-Say Interview Answer:

“I click each sortable column header and verify data sorts ascending. I click again to confirm descending order, and check that the data sequence is accurate.”

22Date Picker Testing▾

🎯 Scenario Question:

How would you test a date picker?

📋 Key Testing Points:

Valid date selectable
Past date restriction if applicable
Typed date validated
Format correct

🎤 Ready-to-Say Interview Answer:

“I select a valid date from the picker and verify it is accepted. I test date restrictions like disabling past dates. I also type a date manually and confirm format validation works.”

23Notification Testing▾

🎯 Scenario Question:

How do you test notifications?

📋 Key Testing Points:

Action triggers correct notification
Message content is accurate
Notification clears after dismiss

🎤 Ready-to-Say Interview Answer:

“I perform an action that should trigger a notification and verify the correct message appears. I dismiss it and confirm it does not reappear unexpectedly.”

24Email Notification Testing▾

🎯 Scenario Question:

How do you test email notifications?

📋 Key Testing Points:

Action triggers email
Email received in time
Content is correct
Links in email work

🎤 Ready-to-Say Interview Answer:

“I trigger an event that sends an email notification. I verify the email is received, check the subject and body content, and confirm any links work correctly.”

25Data Editing Testing▾

🎯 Scenario Question:

How would you test editing functionality?

📋 Key Testing Points:

Edit an existing record
Save the changes
Verify updated data is displayed

🎤 Ready-to-Say Interview Answer:

“I open an existing record, modify the data, and save changes. I then verify the updated information is correctly displayed in the application.”

26Delete Functionality Testing▾

🎯 Scenario Question:

How do you test delete functionality?

📋 Key Testing Points:

Delete action triggers confirmation
Record removed after confirm
Cancel keeps record

🎤 Ready-to-Say Interview Answer:

“I click delete and verify a confirmation dialog appears. I confirm the deletion and check the record is removed. I also click cancel and confirm the record is retained.”

27Reset Button Testing▾

🎯 Scenario Question:

How do you test a reset button?

📋 Key Testing Points:

All fields cleared on click
Default values restored if applicable

🎤 Ready-to-Say Interview Answer:

“I click the reset button and verify all input fields are cleared. If default values are expected, I confirm they are restored.”

28Image Upload Testing▾

🎯 Scenario Question:

How do you test image upload functionality?

📋 Key Testing Points:

Supported formats accepted
Unsupported rejected
Size limit enforced
Preview shown

🎤 Ready-to-Say Interview Answer:

“I upload supported image formats and verify they are accepted with a preview. I test unsupported formats and oversized files to confirm the system rejects them with a proper message.”

29Data Export Testing▾

🎯 Scenario Question:

How do you test data export functionality?

📋 Key Testing Points:

Export generates file
File format correct — Excel/PDF
Data in file matches the system

🎤 Ready-to-Say Interview Answer:

“I trigger the export and verify the file downloads in the expected format. I open the file and compare data against the system to confirm accuracy.”

30Print Feature Testing▾

🎯 Scenario Question:

How do you test a print feature?

📋 Key Testing Points:

Print preview is correct
All data is visible
Page layout is proper

🎤 Ready-to-Say Interview Answer:

“I open the print preview and verify all data is visible and properly formatted. I check for any cut-off content or layout issues.”

31Accessibility Testing▾

🎯 Scenario Question:

How do you test accessibility?

📋 Key Testing Points:

Keyboard navigation works
Screen reader support
Sufficient color contrast
Alt text on images

🎤 Ready-to-Say Interview Answer:

“I navigate the application using only the keyboard to verify all features are accessible. I check for alt text on images and confirm color contrast meets accessibility standards.”

32Boundary Testing▾

🎯 Scenario Question:

How do you test input boundaries?

📋 Key Testing Points:

Minimum value
Maximum value
Just below and just above the boundary

🎤 Ready-to-Say Interview Answer:

“I test minimum and maximum allowed values in each input field to confirm they are accepted. I also test values just outside the boundary to ensure the system rejects them properly.”

33URL Validation Testing▾

🎯 Scenario Question:

How do you validate URLs?

📋 Key Testing Points:

Correct URL format accepted
Invalid format rejected
No sensitive data in URL

🎤 Ready-to-Say Interview Answer:

“I test URL input fields with valid and invalid formats. I also check that sensitive data such as passwords or tokens are not exposed in the URL.”

34Multi-User Scenario Testing▾

🎯 Scenario Question:

How do you test multiple users accessing the system simultaneously?

📋 Key Testing Points:

Concurrent logins work
Data not mixed between users
No race conditions

🎤 Ready-to-Say Interview Answer:

“I log in with multiple accounts at the same time and perform actions simultaneously. I verify each user sees only their own data and no conflicts or race conditions occur.”

35Page Refresh Scenario▾

🎯 Scenario Question:

What happens if a user refreshes the page during form submission?

📋 Key Testing Points:

No duplicate submission
Data not lost
Confirmation shown once only

🎤 Ready-to-Say Interview Answer:

“I refresh the page mid-submission and verify duplicate records are not created. I also check whether form data is preserved and the action is confirmed only once.”

36Error Recovery Testing▾

🎯 Scenario Question:

How do you test error recovery?

📋 Key Testing Points:

System handles errors gracefully
No crash
Clear message to user
Can retry

🎤 Ready-to-Say Interview Answer:

“I simulate errors such as network timeout or invalid input and verify the system shows a clear message without crashing. I confirm the user can retry successfully.”

37Cancel Button Testing▾

🎯 Scenario Question:

How do you test a cancel button?

📋 Key Testing Points:

User redirected to previous page
Unsaved changes not stored

🎤 Ready-to-Say Interview Answer:

“I click cancel and verify the user is redirected without saving changes. I confirm no partial data is stored.”

38User Role Testing▾

🎯 Scenario Question:

How do you test user roles and permissions?

📋 Key Testing Points:

Each role sees correct features
Restricted features inaccessible
No privilege escalation

🎤 Ready-to-Say Interview Answer:

“I log in with different user roles and verify each has access only to permitted features. I also try accessing restricted pages via direct URL to confirm access is blocked.”

39Password Change Testing▾

🎯 Scenario Question:

How do you test password change functionality?

📋 Key Testing Points:

Old password required
New password meets rules
Login works with new password

🎤 Ready-to-Say Interview Answer:

“I verify the old password is required before setting a new one. I test rule enforcement. After changing, I log in with the new password to confirm it works.”

40Data Consistency Testing▾

🎯 Scenario Question:

How do you test data consistency across modules?

📋 Key Testing Points:

Same data shows in all related modules
No mismatch between screens

🎤 Ready-to-Say Interview Answer:

“I update data in one module and navigate to all related modules to verify the same data is reflected correctly everywhere.”

Most Visited

📋 Top Manual Testing Interview Questions

🤖 Selenium WebDriver Interview Questions

🔗 REST API Testing with Postman

🗃 SQL Interview Q&A + 23 Learn Modules

☕ Core Java for Testers — OOPs to Collections

⚙ DevOps Interview Q&A for QA Engineers

QA TOOLS & RESOURCES

Useful Tools

🔗

PostmanAPI Testing Tool

🤖

SeleniumWebDriver Docs

✅

TestNGTesting Framework

🐈

GitHubVersion Control

🐞

JiraBug Tracking

🗃

SQLZooPractice SQL

From the Blog

Articles on software testing, interview tips and career advice for Indian IT professionals.

✍️

Articles Coming Soon

We are writing in-depth articles on Manual Testing, Selenium, API Testing, SQL and more. Stay tuned!

Manual TestingSeleniumAPI TestingSQLCareer Tips

About

About CrackIT

Welcome to CrackIT — India's free IT interview preparation platform built for software testers, Java developers, and IT professionals who are serious about cracking their next interview.

We started CrackIT with one goal: give every IT professional in India the best possible interview preparation — completely free.

What We Cover

SQL — From basics to advanced queries, joins, stored procedures and real interview questions
Core Java — OOPs concepts, collections, exception handling, multithreading and tricky interview questions
Manual Testing — SDLC, STLC, test case writing, bug reporting and interview scenarios
Selenium — WebDriver, frameworks, locators, handling dynamic elements
API Testing — REST, SOAP, Postman, status codes and real interview questions
Java Programs — Output-based questions, dry runs, sorting algorithms and pattern programs
Practice Quizzes — Test yourself with real interview-style questions before your big day
Resume Builder — Build a professional IT resume in minutes for free

Who Is This For?

✅ Freshers preparing for their first IT job
✅ Experienced professionals switching companies
✅ Software testers preparing for QA interviews
✅ Java developers brushing up on core concepts
✅ Anyone appearing for IT interviews in India

Our Promise

✅ 100% Free — no fees, no subscriptions, ever
✅ Real interview questions — not just theory
✅ Updated regularly — new content added every week
✅ Simple explanations — complex topics made easy

Contact Us

Have a suggestion, question, or want us to add a new topic?

📧 Email us: learntocrackit@gmail.com

We read every message and respond within 48 hours.

Your dream IT job is one interview away. CrackIT is here to make sure you are ready for it.

— The CrackIT Team

Crack Your

What are you preparing for?

Manual → Automation Engineer Path

Most Asked Interview Questions

Manual → Automation Engineer Path

Most Visited

Useful Tools

From the Blog

About

About CrackIT

What We Cover

Who Is This For?

Our Promise

Contact Us

No comments:

Post a Comment