Cognizant Placement Papers 2024 - Previous Year Questions & Solutions

Cognizant 2024 Placement Papers - Complete Question Bank

This page contains actual Cognizant placement papers from 2024 with 50+ questions from Online Assessment including aptitude, technical MCQs, and coding problems.

2024 Pattern

Cognizant 2024 had role-based assessments. GenC focused on basics, GenC Pro on intermediate DSA, and GenC Elevate on advanced problems.

Cognizant 2024 Assessment Pattern

Role	Aptitude	Technical	Coding	Time
GenC	25 MCQs	10 MCQs	1-2 problems	90 min
GenC Pro	25 MCQs	15 MCQs	2 problems	120 min
GenC Elevate	20 MCQs	15 MCQs	3 problems	150 min

Aptitude Questions (2024 Actual)

Question 1: Time and Work

A can complete work in 10 days, B in 15 days. They work together for 4 days, then A leaves. How many more days for B to finish?

Solution:

• LCM(10,15) = 30 units total work
• A’s efficiency = 3 units/day, B’s efficiency = 2 units/day
• Combined = 5 units/day
• Work done in 4 days = 20 units
• Remaining = 10 units
• B alone = 10/2 = 5 days

Question 2: Profit and Loss

An item is sold at 20% profit. If CP is ₹800, what is SP?

Solution:

• SP = CP × (1 + Profit%)
• SP = 800 × 1.20 = ₹960

Question 3: Percentage

A number is increased by 20% then decreased by 20%. Net change?

Solution:

• Let number = 100
• After 20% increase = 120
• After 20% decrease = 120 × 0.8 = 96
• Net change = -4%

Question 4: Ratio

If A:B = 2:3 and B:C = 4:5, find A:B:C

Solution:

• A:B = 2:3 = 8:12
• B:C = 4:5 = 12:15
• A:B:C = 8:12:15

Question 5: Speed and Distance

A train 100m long crosses a 200m platform in 30 seconds. Find speed.

Solution:

• Total distance = 100 + 200 = 300m
• Time = 30 seconds
• Speed = 300/30 = 10 m/s = 36 km/hr

Question 6: Simple Interest

SI on ₹5000 for 2 years at 8% per annum?

Solution:

• SI = (P × R × T) / 100
• SI = (5000 × 8 × 2) / 100 = ₹800

Question 7: Average

Average of 5 numbers is 20. If one number is removed, average becomes 18. Find removed number.

Solution:

• Total = 5 × 20 = 100
• New total = 4 × 18 = 72
• Removed = 100 - 72 = 28

Question 8: Mixture

Milk and water in ratio 4:1. How much water to add to 10L to make ratio 2:3?

Solution:

• Milk = 8L, Water = 2L
• Let x liters water added
• 8/(2+x) = 2/3
• 24 = 4 + 2x → x = 10 liters

Logical Reasoning (2024)

Question 9: Coding-Decoding

If COMPUTER = RFUVQNPC, how is PRINTER coded?

Solution:

• Pattern: Reverse order + shift by 1
• PRINTER → RETNIRP → SFUOJSQ

Question 10: Blood Relations

A is B’s father. C is A’s father. D is C’s father. How is D related to B?

Solution:

• A = B’s father
• C = A’s father (B’s grandfather)
• D = C’s father (B’s great-grandfather)

Question 11: Series

Find next: 2, 6, 12, 20, 30, ?

Solution:

• Differences: 4, 6, 8, 10, 12
• Next = 30 + 12 = 42

Question 12: Syllogism

All dogs are cats. All cats are rats. Conclusion: All dogs are rats?

Solution: True (follows from both premises)

Technical MCQs (2024)

Question 13: Programming

What is the output? int a=5; printf(“%d”,a++);

Answer: 5 (post-increment prints first, then increments)

Question 14: DBMS

Which key uniquely identifies a row?

Answer: Primary Key

Question 15: OOPs

What is encapsulation?

Answer: Bundling data and methods that operate on data within a single unit (class)

Question 16: SQL

Query to select all employees with salary > 50000?

SELECT * FROM employees WHERE salary > 50000;

Question 17: OS

What is deadlock?

Answer: A situation where two or more processes are waiting for each other indefinitely

Coding Problems (2024)

Problem 1: Reverse String (GenC)

Problem

Difficulty: Easy
Time: 15 minutes

Reverse a given string without using built-in functions.

Input: “hello”
Output: “olleh”

C

void reverseString(char str[]) {
    int n = strlen(str);
    for(int i = 0; i < n/2; i++) {
        char temp = str[i];
        str[i] = str[n-1-i];
        str[n-1-i] = temp;
    }
}

Java

public String reverse(String s) {
    char[] arr = s.toCharArray();
    int left = 0, right = arr.length - 1;
    while (left < right) {
        char temp = arr[left];
        arr[left++] = arr[right];
        arr[right--] = temp;
    }
    return new String(arr);
}

Python

def reverse_string(s):
    chars = list(s)
    left, right = 0, len(chars) - 1
    while left < right:
        chars[left], chars[right] = chars[right], chars[left]
        left += 1
        right -= 1
    return ''.join(chars)

Problem 2: Find Second Largest (GenC)

Problem

Difficulty: Easy
Time: 15 minutes

Find second largest element in an array.

Input: [12, 35, 1, 10, 34, 1]
Output: 34

C

int secondLargest(int arr[], int n) {
    int first = INT_MIN, second = INT_MIN;
    for(int i = 0; i < n; i++) {
        if(arr[i] > first) {
            second = first;
            first = arr[i];
        } else if(arr[i] > second && arr[i] != first) {
            second = arr[i];
        }
    }
    return second;
}

Java

public int secondLargest(int[] arr) {
    int first = Integer.MIN_VALUE;
    int second = Integer.MIN_VALUE;
    for (int num : arr) {
        if (num > first) {
            second = first;
            first = num;
        } else if (num > second && num != first) {
            second = num;
        }
    }
    return second;
}

Python

def second_largest(arr):
    first = second = float('-inf')
    for num in arr:
        if num > first:
            second = first
            first = num
        elif num > second and num != first:
            second = num
    return second

Problem 3: Check Palindrome (GenC)

Problem

Difficulty: Easy
Time: 15 minutes

Check if a number is palindrome.

Input: 121
Output: true

Java

public boolean isPalindrome(int x) {
    if (x < 0) return false;
    int original = x, reversed = 0;
    while (x > 0) {
        reversed = reversed * 10 + x % 10;
        x /= 10;
    }
    return original == reversed;
}

Python

def is_palindrome(x):
    if x < 0: return False
    original = x
    reversed_num = 0
    while x > 0:
        reversed_num = reversed_num * 10 + x % 10
        x //= 10
    return original == reversed_num

Problem 4: Two Sum (GenC Pro)

Problem

Difficulty: Medium
Time: 20 minutes

Find two numbers in array that add up to target.

Input: nums = [2,7,11,15], target = 9
Output: [0, 1]

Java

public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (map.containsKey(complement)) {
            return new int[]{map.get(complement), i};
        }
        map.put(nums[i], i);
    }
    return new int[]{};
}

Python

def two_sum(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []

Problem 5: Longest Palindromic Substring (GenC Pro)

Problem

Difficulty: Medium
Time: 25 minutes

Find the longest palindromic substring.

Input: “babad”
Output: “bab” or “aba”

Java

public String longestPalindrome(String s) {
    if (s == null || s.length() < 1) return "";
    int start = 0, end = 0;
    for (int i = 0; i < s.length(); i++) {
        int len1 = expandAroundCenter(s, i, i);
        int len2 = expandAroundCenter(s, i, i + 1);
        int len = Math.max(len1, len2);
        if (len > end - start) {
            start = i - (len - 1) / 2;
            end = i + len / 2;
        }
    }
    return s.substring(start, end + 1);
}

private int expandAroundCenter(String s, int left, int right) {
    while (left >= 0 && right < s.length() &&
           s.charAt(left) == s.charAt(right)) {
        left--;
        right++;
    }
    return right - left - 1;
}

Python

def longest_palindrome(s):
    def expand_around_center(left, right):
        while left >= 0 and right < len(s) and s[left] == s[right]:
            left -= 1
            right += 1
        return s[left + 1:right]

    result = ""
    for i in range(len(s)):
        # Odd length palindrome
        odd = expand_around_center(i, i)
        # Even length palindrome
        even = expand_around_center(i, i + 1)
        # Update result
        if len(odd) > len(result):
            result = odd
        if len(even) > len(result):
            result = even
    return result

Problem 6: Merge Sorted Arrays (GenC Elevate)

Problem

Difficulty: Medium
Time: 20 minutes

Merge two sorted arrays into one sorted array.

Input: [1,3,5], [2,4,6]
Output: [1,2,3,4,5,6]

Java

public int[] merge(int[] arr1, int[] arr2) {
    int[] result = new int[arr1.length + arr2.length];
    int i = 0, j = 0, k = 0;
    while (i < arr1.length && j < arr2.length) {
        if (arr1[i] <= arr2[j]) {
            result[k++] = arr1[i++];
        } else {
            result[k++] = arr2[j++];
        }
    }
    while (i < arr1.length) result[k++] = arr1[i++];
    while (j < arr2.length) result[k++] = arr2[j++];
    return result;
}

Python

def merge_sorted(arr1, arr2):
    result = []
    i = j = 0
    while i < len(arr1) and j < len(arr2):
        if arr1[i] <= arr2[j]:
            result.append(arr1[i])
            i += 1
        else:
            result.append(arr2[j])
            j += 1
    result.extend(arr1[i:])
    result.extend(arr2[j:])
    return result

Key Insights from 2024

1. Role-Based Assessment: Different difficulty levels for GenC, Pro, and Elevate
2. Aptitude Critical: Strong aptitude performance required for all roles
3. Time Management: 90-150 minutes based on role - practice speed
4. Coding Focus: Basic problems for GenC, intermediate for Pro, advanced for Elevate
5. Technical MCQs: Programming, DBMS, OOPs are key topics
6. Success Rate: ~30% for GenC, ~20% for Pro, ~15% for Elevate

2024 Interview Experiences

Common Interview Questions:

• OOPs concepts (4 pillars)
• DBMS normalization
• SQL queries
• Project discussion
• Behavioral questions

Related Resources

Cognizant 2025 Papers

Latest placement papers. View 2025 Papers →

Cognizant Coding Questions

25+ coding problems. View Coding →

Cognizant Interview Experience

Real experiences. Read Experiences →

Complete Guide

Full Cognizant guide. View Guide →

---

Practice these 2024 papers to understand the pattern!

Last updated: January 2026