Tcs nqt coding questions and answers

TCS Coding Interview Questions - Preparation Guide

Tata Consultancy Services (TCS) is one of the leading IT services companies in India. Their recruitment drives are known for a balanced mix of multiple-choice questions (MCQs) and coding problems that assess candidates' problem-solving abilities and technical knowledge. This guide provides an overview of TCS's coding question patterns and presents 20 essential coding problems with Python solutions to help you prepare effectively.

About TCS and Their Question Pattern

TCS recruitment exams typically consist of 10 coding problems that cover a range of topics including Data Structures, Algorithms, and Strings. These questions vary in difficulty from beginner to hard and are designed to be solved within a 90-minute timeframe, although this may vary.

Topic	Details
Number of Questions	10 Coding Problems
Topics Covered	Data Structures, Algorithms, Strings
Difficulty Level	Beginner to Hard
Time Duration	90 minutes (may vary)

TCS Coding Questions and Solutions

Below are 20 important coding questions frequently asked in TCS recruitment exams, along with their solutions provided in Python:

1. Reverse a String in Python

This question tests your ability to manipulate strings efficiently.


def reverse_string(s):
    return s[::-1]

# Example usage:
print(reverse_string("hello"))  # Output: "olleh"

2. Check if a String is a Palindrome

Determine whether a given string reads the same forwards and backwards.


def is_palindrome(s):
    return s == s[::-1]

# Example usage:
print(is_palindrome("racecar"))  # Output: True

3. Find the Factorial of a Number

Calculate the factorial of a given non-negative integer using recursion.


def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

# Example usage:
print(factorial(5))  # Output: 120

4. Implement a Binary Search Algorithm

Search for a target value within a sorted array efficiently.


def binary_search(arr, target):
    low, high = 0, len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1

# Example usage:
print(binary_search([1, 2, 3, 4, 5], 3))  # Output: 2

5. Implement a Bubble Sort Algorithm

Sort an array of numbers using the Bubble Sort technique.


def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

# Example usage:
print(bubble_sort([5, 3, 2, 4, 1]))  # Output: [1, 2, 3, 4, 5]

6. Find the Maximum Element in an Array

Identify the largest number in a given array.


def find_max(arr):
    max_element = arr[0]
    for num in arr:
        if num > max_element:
            max_element = num
    return max_element

# Example usage:
print(find_max([5, 3, 9, 1, 7]))  # Output: 9

7. Calculate Fibonacci Sequence up to a Certain Number

Generate the Fibonacci sequence up to a specified limit.


def fibonacci(n):
    fib_sequence = [0, 1]
    while fib_sequence[-1] < n:
        fib_sequence.append(fib_sequence[-1] + fib_sequence[-2])
    return fib_sequence[:-1]

# Example usage:
print(fibonacci(50))  # Output: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

8. Remove Duplicates from a List in Python

Eliminate duplicate elements from a list, preserving unique values.


def remove_duplicates(arr):
    return list(set(arr))

# Example usage:
print(remove_duplicates([1, 2, 2, 3, 4, 4, 5]))  # Output: [1, 2, 3, 4, 5]

9. Check if a Number is Prime in Python

Determine whether a given number is a prime number.


def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

# Example usage:
print(is_prime(17))  # Output: True

10. Find the Sum of Digits of a Number in Python

Calculate the sum of all digits in a given integer.


def sum_of_digits(n):
    return sum(int(digit) for digit in str(n))

# Example usage:
print(sum_of_digits(12345))  # Output: 15

11. Implement a Stack in Python

Create a stack data structure with basic operations like push, pop, and peek.


class Stack:
    def __init__(self):
        self.items = []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        if not self.is_empty():
            return self.items.pop()

    def is_empty(self):
        return len(self.items) == 0

    def peek(self):
        if not self.is_empty():
            return self.items[-1]

    def size(self):
        return len(self.items)

# Example usage:
stack = Stack()
stack.push(1)
stack.push(2)
print(stack.peek())  # Output: 2
stack.pop()
print(stack.peek())  # Output: 1

12. Implement a Queue in Python

Create a queue data structure with basic operations like enqueue, dequeue, and size.


class Queue:
    def __init__(self):
        self.items = []

    def enqueue(self, item):
        self.items.append(item)

    def dequeue(self):
        if not self.is_empty():
            return self.items.pop(0)

    def is_empty(self):
        return len(self.items) == 0

    def size(self):
        return len(self.items)

# Example usage:
queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
print(queue.dequeue())  # Output: 1

13. Find the Intersection of Two Arrays in Python

Identify common elements between two arrays.


def intersection(arr1, arr2):
    return list(set(arr1) & set(arr2))

# Example usage:
print(intersection([1, 2, 3, 4], [3, 4, 5, 6]))  # Output: [3, 4]

14. Count the Occurrences of Each Word in a Sentence in Python

Count how many times each word appears in a given sentence.


def word_count(sentence):
    words = sentence.split()
    word_count_dict = {}
    for word in words:
        if word in word_count_dict:
            word_count_dict[word] += 1
        else:
            word_count_dict[word] = 1
    return word_count_dict

# Example usage:
print(word_count("the quick brown fox jumps over the lazy dog"))
# Output: {'the': 2, 'quick': 1, 'brown': 1, 'fox': 1, 'jumps': 1, 'over': 1, 'lazy': 1, 'dog': 1}

15. Implement a Linked List in Python

Create a singly linked list with basic operations such as insertion and traversal.


class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    def insert(self, data):
        new_node = Node(data)
        new_node.next = self.head
        self.head = new_node

    def traverse(self):
        current = self.head
        while current:
            print(current.data, end=' ')
            current = current.next

# Example usage:
ll = LinkedList()
ll.insert(3)
ll.insert(2)
ll.insert(1)
ll.traverse()  # Output: 1 2 3

16. Find the Missing Number in an Array Containing 1 to N in Python

Identify the missing number in a sequence from 1 to N.


def find_missing_number(nums):
    n = len(nums) + 1
    total_sum = n * (n + 1) // 2
    actual_sum = sum(nums)
    return total_sum - actual_sum

# Example usage:
print(find_missing_number([1, 2, 4, 5]))  # Output: 3

17. Check if Two Strings are Anagrams of Each Other in Python

Determine whether two strings are anagrams, meaning they contain the same characters in a different order.


def are_anagrams(s1, s2):
    return sorted(s1) == sorted(s2)

# Example usage:
print(are_anagrams("listen", "silent"))  # Output: True

18. Find the First Non-Repeating Character in a String in Python

Identify the first character in a string that does not repeat.


def first_non_repeating_char(s):
    char_count = {}
    for char in s:
        if char in char_count:
            char_count[char] += 1
        else:
            char_count[char] = 1
    for char in s:
        if char_count[char] == 1:
            return char
    return None

# Example usage:
print(first_non_repeating_char("hello"))  # Output: 'h'

19. Rotate an Array to the Right by K Steps in Python

Rotate the elements of an array to the right by K steps.


def rotate_array(nums, k):
    k %= len(nums)
    nums[:] = nums[-k:] + nums[:-k]

# Example usage:
arr = [1, 2, 3, 4, 5]
rotate_array(arr, 2)
print(arr)  # Output: [4, 5, 1, 2, 3]

20. Find the Intersection of Two Linked Lists in Python

Determine the node at which two singly linked lists intersect.


class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def get_intersection_node(headA, headB):
    pointerA, pointerB = headA, headB
    while pointerA != pointerB:
        pointerA = pointerA.next if pointerA else headB
        pointerB = pointerB.next if pointerB else headA
    return pointerA

# Example usage:
# Construct linked lists
intersect_node = ListNode(3)
intersect_node.next = ListNode(4)

headA = ListNode(1)
headA.next = ListNode(2)
headA.next.next = intersect_node

headB = ListNode(5)
headB.next = ListNode(6)
headB.next.next = intersect_node

intersection = get_intersection_node(headA, headB)
print(intersection.val)  # Output: 3

Conclusion

Preparing for TCS coding interviews requires a solid understanding of fundamental programming concepts and problem-solving skills. By practicing these 20 coding problems, you'll be well-equipped to tackle the challenges presented in TCS's recruitment exams. Remember to not only understand the solutions but also to practice implementing them on your own to reinforce your learning. Good luck with your preparation!

LearnCodePro

Tcs nqt coding questions and answers