Wipro NLTH Online Test – Complete Paper

Date: February 25, 2025
Location: VIT Vellore Campus
Duration: 115 Minutes
Total Questions: 92

Part A: Quantitative Aptitude (32 Questions)

1. A train traveling at 72 km/hr crosses a pole in 30 seconds. What is the length of the train?
   • 400 meters
   • 500 meters
   • 600 meters
   • 700 meters
2. The ratio of boys to girls in a class is 3:2. If 10 more boys join the class, the ratio becomes 7:4. Find the original number of students.
   • 40
   • 50
   • 60
   • 70

Part B: Verbal Ability (20 Questions)

1. Choose the correct synonym for "Benevolent":
   • Malevolent
   • Kind
   • Stingy
   • Hostile

Part C: Coding Section

Write the code for the following problems:

// Problem 1: Inventory Management System
package com.wipro.inventory;

import java.util.*;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.stream.Collectors;

/**
 * Production-ready Inventory Management System
 * Demonstrates SOLID principles and clean code practices
 */
public class InventoryManagementSystem {

    // Product Entity (Immutable)
    public static class Product {
        private final String productId;
        private final String name;
        private final String category;
        private final double price;
        private final int quantity;
        private final LocalDate expiryDate;
        private final double discount;

        public Product(String productId, String name, String category,
                       double price, int quantity, LocalDate expiryDate, double discount) {

            validateProduct(productId, name, price, quantity);
            this.productId = productId;
            this.name = name;
            this.category = category;
            this.price = price;
            this.quantity = quantity;
            this.expiryDate = expiryDate;
            this.discount = discount;
        }

        private void validateProduct(String id, String name, double price, int quantity) {
            if (id == null || id.trim().isEmpty())
                throw new IllegalArgumentException("Product ID cannot be empty");
            if (name == null || name.trim().isEmpty())
                throw new IllegalArgumentException("Product name cannot be empty");
            if (price <= 0)
                throw new IllegalArgumentException("Price must be positive");
            if (quantity < 0)
                throw new IllegalArgumentException("Quantity cannot be negative");
        }

        public double getDiscountedPrice() {
            return price - (price * discount / 100);
        }

        public boolean isExpired() {
            return expiryDate != null && expiryDate.isBefore(LocalDate.now());
        }

        public String getProductId() { return productId; }
        public String getName() { return name; }
        public String getCategory() { return category; }
        public double getPrice() { return price; }
        public int getQuantity() { return quantity; }
        public LocalDate getExpiryDate() { return expiryDate; }
        public double getDiscount() { return discount; }

        @Override
        public String toString() {
            return String.format(
                "Product[ID: %s, Name: %s, Category: %s, Price: ₹%.2f, Qty: %d, Expiry: %s, Discount: %.1f%%]",
                productId, name, category, price, quantity, expiryDate, discount
            );
        }
    }

    // Inventory Service
    public static class InventoryService {
        private final Map inventory = new HashMap<>();
        private final List transactionLog = new ArrayList<>();

        public void addProduct(Product product) {
            if (inventory.containsKey(product.getProductId()))
                throw new IllegalArgumentException("Product already exists");
            inventory.put(product.getProductId(), product);
        }

        public boolean sellProduct(String productId, int qty) {
            Product product = inventory.get(productId);
            if (product == null || product.getQuantity() < qty || product.isExpired())
                return false;

            Product updated = new Product(
                product.getProductId(), product.getName(), product.getCategory(),
                product.getPrice(), product.getQuantity() - qty,
                product.getExpiryDate(), product.getDiscount()
            );

            inventory.put(productId, updated);
            return true;
        }

        public List getLowStockProducts(int threshold) {
            return inventory.values().stream()
                .filter(p -> p.getQuantity() <= threshold)
                .sorted(Comparator.comparing(Product::getQuantity))
                .collect(Collectors.toList());
        }
    }
}
    

// Problem 2: E-Commerce Order Processing System
package com.wipro.ecommerce;

import java.util.*;
import java.time.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Thread-safe E-Commerce Order Processing System
 */
public class OrderProcessingSystem {

    public enum OrderStatus { PENDING, PROCESSING, SHIPPED, DELIVERED, CANCELLED }
    public enum PaymentStatus { PENDING, SUCCESS, FAILED, REFUNDED }

    public static class Customer {
        private final String customerId;
        private final String name;
        private final String email;
        private final String phone;

        public Customer(String id, String name, String email, String phone) {
            this.customerId = id;
            this.name = name;
            this.email = email;
            this.phone = phone;
        }
    }

    public static class OrderService {
        private final ConcurrentHashMap orders = new ConcurrentHashMap<>();
        private final AtomicInteger orderCounter = new AtomicInteger(1000);

        public String placeOrder() {
            String orderId = "ORD" + orderCounter.incrementAndGet();
            orders.put(orderId, "PROCESSING");
            return orderId;
        }
    }
}
    

Technical Interview Questions Asked:

• Explain the difference between ArrayList and LinkedList
• What is method overloading vs overriding?
• How does garbage collection work in Java?
• What are SQL joins? Explain different types
• What is normalization in databases?

HR Interview Questions:

• Tell me about yourself
• Why do you want to join Wipro?
• What are your strengths and weaknesses?
• Where do you see yourself in 5 years?
• Are you willing to relocate?

Coding Problems Asked in Interview:

// Question: Implement LRU Cache

import java.util.*;

class LRUCache {

    class Node {
        int key;
        int value;
        Node prev;
        Node next;

        Node(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }

    private final int capacity;
    private final Map cache;
    private final Node head;
    private final Node tail;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.cache = new HashMap<>();

        // Dummy nodes
        this.head = new Node(0, 0);
        this.tail = new Node(0, 0);

        head.next = tail;
        tail.prev = head;
    }

    public int get(int key) {
        if (!cache.containsKey(key)) {
            return -1;
        }

        Node node = cache.get(key);
        remove(node);
        addToFront(node);
        return node.value;
    }

    public void put(int key, int value) {
        if (cache.containsKey(key)) {
            Node node = cache.get(key);
            node.value = value;
            remove(node);
            addToFront(node);
        } else {
            if (cache.size() == capacity) {
                Node lru = tail.prev;
                remove(lru);
                cache.remove(lru.key);
            }

            Node newNode = new Node(key, value);
            cache.put(key, newNode);
            addToFront(newNode);
        }
    }

    private void addToFront(Node node) {
        node.next = head.next;
        node.prev = head;
        head.next.prev = node;
        head.next = node;
    }

    private void remove(Node node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    // Test Method
    public static void main(String[] args) {
        LRUCache cache = new LRUCache(2);

        cache.put(1, 1);
        cache.put(2, 2);

        System.out.println(cache.get(1)); // returns 1

        cache.put(3, 3); // evicts key 2
        System.out.println(cache.get(2)); // returns -1

        cache.put(4, 4); // evicts key 1
        System.out.println(cache.get(1)); // returns -1
        System.out.println(cache.get(3)); // returns 3
        System.out.println(cache.get(4)); // returns 4
    }
}
    

-- SQL Questions Asked in Wipro Interview

-- 1. Find second highest salary
SELECT MAX(salary)
FROM employees
WHERE salary <
(
    SELECT MAX(salary)
    FROM employees
);

-- 2. Find duplicate records
SELECT name, email, COUNT(*)
FROM users
GROUP BY name, email
HAVING COUNT(*) > 1;

-- 3. Department-wise highest salary
SELECT d.dept_name, e.emp_name, e.salary
FROM employees e
JOIN departments d 
ON e.dept_id = d.dept_id
WHERE (e.dept_id, e.salary) IN
(
    SELECT dept_id, MAX(salary)
    FROM employees
    GROUP BY dept_id
);

-- 4. Employees hired in last 30 days
SELECT emp_name, hire_date
FROM employees
WHERE hire_date >= DATE_SUB(CURDATE(), INTERVAL 30 DAY);

-- 5. Monthly salary report
SELECT 
    DATE_FORMAT(payment_date, '%Y-%m') AS month,
    COUNT(*) AS employees_paid,
    SUM(amount) AS total_salary,
    AVG(amount) AS average_salary
FROM salary_payments
GROUP BY DATE_FORMAT(payment_date, '%Y-%m')
ORDER BY month DESC;
    

Preparation Tips for Wipro 2025:

1. Quantitative Aptitude: Focus on percentages, ratios, and time–speed–distance.
2. Coding Practice: Solve at least 50 problems on arrays and strings.
3. Technical Concepts: Revise OOPs, DBMS, and basic DSA thoroughly.
4. Mock Tests: Take 10+ full-length mock tests.
5. Communication: Practice explaining your projects clearly and confidently.

Note: Wipro focuses heavily on problem-solving skills and clean code. Make sure your code is well-commented and handles edge cases properly.