Top 40 TCS Coding Interview Questions and Answers (2024)

Tata Consultancy Services (TCS) is India’s leading IT services and consultancy company with offices in over 46 countries. It is widely recognized for its expertise in digital transformation, especially in AI and machine learning, cloud computing, software development, cybersecurity, and data analytics. As a result, the company seeks candidates with a solid foundation in computer science, particularly in programming skills. If you want to apply for a job role at TCS, this blog is just for you. We have compiled a list of TCS coding job interview questions for freshers, mid-level, and experienced candidates to help you succeed in your upcoming interview.

TCS Coding Interview Questions and Answers for Freshers

When preparing for a TCS interview, especially for entry-level positions, it is essential to focus on the basic questions that assess your academic understanding and foundational coding skills. Here are some basic TCS coding interview questions and answers.

Q1. How can you reverse a string in Python?

Sample Answer: To reverse a string in Python, use the slicing method. This method allows you to create a new string that reads backward by specifying a step of -1. It is a concise and efficient way to achieve the desired result. 
Here is a code to reverse a string in Python:

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

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

Q2. Write a code using the C program to check if the mentioned year is a leap year or not using command line arguments.

Sample Answer: Use the year as the command line argument in a C program to determine whether a year is a leap year. Here’s how we can check whether the mentioned year is a leap year or not.

#include<stdio.h>
int main(int a, char b[])
{
int year; year=atoi(b[1]);
if(year%100==0)
{
if(year%400==0)
{
printf(“IT IS A LEAP YEAR”);
}
else{
printf(“IT IS NOT A LEAP YEAR”);}}
elseif(year%4==0)
{
printf(“IT IS A LEAP YEAR”);
}
else{
printf(“IT IS NOT A LEAP YEAR”);
}
return 0; }

Q3. How can you check if a string is palindrome in Python?

Sample Answer: A string is classified as a palindrome if it reads the same forwards and backward. In Python, this can be easily checked by comparing the original string with its reversed version. 

Here’s a code that can help you in checking if a string is palindrome:

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

# Example usage:
print(is_palindrome("noon"))  # Output: True
print(is_palindrome("monday")) # Output: False

Q4. Write a program to start a binary search algorithm in Python.

Sample Answer: A binary search is an algorithm that helps find the value of a sorted array. Here’s how we can do a binary search in Python.

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

Q5. Write a function to check if two strings are anagrams.

Sample Answer: An anagram is multiple words or phrases that can give the same value despite rearranging the letters. Here is a function to check whether two strings are anagrams:

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

# Test case 
print(are_anagrams("cork", "rock")) # Output: True 
print(are_anagrams("universe", "paris")) # Output: False

Q6. How can you conduct a bubble sort algorithm in Python?

Sample Answer: Bubble sort is a simple sorting algorithm that repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order. The following code outlines how we can conduct a bubble sort algorithm in Python:

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]

Q7. How can you merge two sorted arrays?

Sample Answer: Merging two sorted arrays involves combining them into one sorted array while maintaining order. We can merge two sorted arrays into a single sorted array by following the given code.

def merge_sorted_arrays(arr1, arr2): 
result = [] 
i, j = 0, 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 

# Test case 
print(merge_sorted_arrays([1, 3, 5], [2, 4, 6])) # Output: [1, 2, 3, 4, 5, 6]

Q8. How can you find the factorial of a number in Python?

Sample Answer: The factorial of a number represents the product of all positive integers up to that number. We can find the factorial value of a number by writing the given code.

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

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

Q9. Write a program to count occurrences of an element.

Sample Answer: Here’s a program that can help you count the occurrences of a specific element in an array.

def count_occurrences(arr, element): 
               return arr.count(element)

 # Test case
 print(count_occurrences([1, 2, 2, 3, 2, 4], 2)) # Output: 3

Q10. How can you find a missing number if you are provided with a list of integers from 1 to n?

Sample Answer: Here’s a code to find the missing number in a list of integers from 1 to n.

def find_missing(arr, n):
    expected_sum = n * (n + 1) // 2
    actual_sum = sum(arr)
    return expected_sum - actual_sum

# Test case
print(find_missing([1, 2, 3, 5], 5))  # Output: 4

Q11. Write a program to remove duplicate elements from an array.

Sample Answer: Duplicates in an array can be removed by converting it into a set, which inherently eliminates duplicates. Here’s how we can remove duplicate elements from an array:

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

# Test case 
print(remove_duplicates([1, 2, 2, 3, 4, 4, 5])) # Output: [1, 2, 3, 4, 5]

Q12. How can you conduct a check for an Armstrong number?

Sample Answer: An Armstrong number is a number that equals the sum of its digits, where each digit is raised to the power of the total number of digits in the number. Here’s how we can check for an Armstrong number:

def is_armstrong(n): 
     num_str = str(n) 
     power = len(num_str)
     return n == sum(int(digit) ** power for digit in num_str)

 # Test case 

print(is_armstrong(153)) # Output: True 
print(is_armstrong(123)) # Output: False

Q13. Write a program to check if the mentioned number is a prime number or not.

Sample Answer: To determine if a number is prime, you need to check for divisibility by any integer other than 1 and itself. By following the given program we can check if the 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

 # Test case 

print(is_prime(7)) # Output: True
 print(is_prime(10)) # Output: False

Q14. How can you find the largest number in an array?

Sample Answer: Here is how to find the largest number in an array using Python’s max () function:

def find_largest(arr): 
       return max(arr) 

# Test case 
print(find_largest([1, 2, 3, 4, 5])) # Output: 5

Q15. How can you calculate the sum of digits?

Sample Answer: Here’s a function to calculate the sum of digits.

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

# Test case 
print(sum_of_digits(1234)) # Output: 10

Pro Tip: You can start a career with TCS through an internship. The company posts internship opportunities on its career webpage and offers training programs for young professionals. Check out our guide on how to get an internship at TCS and build your career.

Coding Questions Asked in TCS Interview for Mid-Level Professionals

When interviewing for a mid-level position at TCS, you can expect coding questions that test your understanding of fundamental concepts and problem-solving skills. Here are some TCS coding interview questions with answers for mid-level professionals.

Q16. How can you merge overlapping intervals in an array of intervals?

Sample Answer: It can be merged by grouping all the intervals by sorting them and then starting with the first interval and comparing it with the rest. Here’s how you can implement it:

def merge_intervals(intervals): 
     intervals.sort(key=lambda x: x[0]) 
     merged = [intervals[0]]
      for current in intervals[1:]: 
           last = merged[-1] 
           if current[0] <= last[1]:  # Overlap
            last[1] = max(last[1], current[1])
 else:
 merged.append(current)
 return merged 

# Test case 
print(merge_intervals([[1, 3], [2, 6], [8, 10], [15, 18]]))
# Output: [[1, 6], [8, 10], [15, 18]]

Q17. Write a program to implement a queue using stacks.

Sample Answer: By using one stack for input and another for output, you can manage the order of elements effectively. This approach allows you to maintain the FIFO (First In, First Out) principle of queues while using the LIFO (Last In, First Out) nature of stacks. 

We can implement a queue using stacks by following the given code.

class MyQueue:
    def __init__(self):
        self.stack_in = []
        self.stack_out = []

    def push(self, x):
        self.stack_in.append(x)

    def pop(self):
        self.peek()
        return self.stack_out.pop()

    def peek(self):
        if not self.stack_out:
            while self.stack_in:
                self.stack_out.append(self.stack_in.pop())
        return self.stack_out[-1]

    def empty(self):
        return not self.stack_in and not self.stack_out

# Example usage:
# queue = MyQueue()
# queue.push(1)
# queue.push(2)
# queue.peek()  # Output: 1
# queue.pop()   # Output: 1

Q18. If provided an array of integers how can you find two numbers that add up to a specific target?

Sample Answer: To find two numbers in an array that sum up to a specific target, you can use a HashMap to track the numbers you have encountered so far. This allows for efficient lookups to check if the complement (the difference between the target and the current number) exists in the map. 

Here is a code to find the specific target by using a HashMap:

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

# Test case
print(two_sum([2, 7, 11, 15], 9))  # Output: [0, 1]

Q19. Remove the Nth Node from the end of a singly linked list in Python.

Sample Answer: We can remove the Nth node from the end of a singly linked list by using two pointers. Here’s how you can implement it:

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

def remove_nth_from_end(head, n):
    dummy = ListNode(0)
    dummy.next = head
    fast = slow = dummy
    
    for _ in range(n + 1):
        fast = fast.next
    
    while fast:
        fast = fast.next
        slow = slow.next

    slow.next = slow.next.next
    return dummy.next

# Example usage:
# head = [1, 2, 3, 4, 5], n = 2, Output: [1, 2, 3, 5]

Q20. Write a program to find duplicate elements in an array.

Sample Answer: To identify duplicate elements in an array, we can iterate through each element and track the ones we have already seen using a set. If we encounter an element that’s already in the set, it means it is a duplicate. We can find duplicate elements in an array by following the given code.

def find_duplicates(arr):
    duplicates = []
    seen = set()
    for num in arr:
        if num in seen:
            duplicates.append(num)
        else:
            seen.add(num)
    return duplicates

# Test case
print(find_duplicates([1, 2, 3, 2, 4, 5, 3]))  # Output: [2, 3]

Pro Tip: The coding test is a part of the selection process for many job profiles at TCS. It is important to practice coding questions as per the profile requirements and expertise as needed. Check out our following guides to explore Java, Angular, and Python-related conceptual and coding job interview questions at TCS:

• Java Developer Interview Questions at TCS
• Angular Interview Questions at TCS
• Python Interview Questions at TCS

Q21. How can you check if a string containing parentheses is balanced?

Sample Answer: To check if a string containing parentheses is balanced, we use a stack. We push opening parentheses onto the stack, and for each closing parenthesis, we check if it matches the last opened parenthesis by popping the stack. If everything matches correctly, the string is balanced. Here’s the code to check whether a parenthesis is balanced or not.

def is_balanced(s):
    stack = []
    mapping = {')': '(', '}': '{', ']': '['}
    for char in s:
        if char in mapping:
            top_element = stack.pop() if stack else '#'
            if mapping[char] != top_element:
                return False
        else:
            stack.append(char)
    return not stack

# Test case
print(is_balanced("()[]{}"))  # Output: True
print(is_balanced("(]"))      # Output: False

Q22. How can you implement a binary search on a sorted array of integers?

Sample Answer: You can conduct a binary search on a sorted array of integers by repeatedly dividing the search interval in half. Here’s the code to implement a binary search on a sorted array of integers:

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

# Test case
print(binary_search([1, 2, 3, 4, 5], 3))  # Output: 2

Q23. Write a code to rotate an array by k positions.

Sample Answer: To rotate an array by k positions, we can use slicing to rearrange the elements. The key is to split the array into two parts: the last k elements and the first n-k elements, and then concatenate them. The following code illustrates how can we rotate an array by k positions.

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

# Test case
print(rotate_array([1, 2, 3, 4, 5, 6, 7], 3))  # Output: [5, 6, 7, 1, 2, 3, 4]

Q24. Write a program to find the length of the longest substring without repeating characters in a given string.

Sample Answer: To find the length of the longest substring without repeating characters, we use the sliding window technique with two pointers (left and right). This helps efficiently track the longest substring as we move through the string.  Here’s how we can find the length of the longest substring without repeating any characters.

def longest_unique_substring(s):
    char_map = {}
    left = max_length = 0
    for right, char in enumerate(s):
        if char in char_map and char_map[char] >= left:
            left = char_map[char] + 1
        char_map[char] = right
        max_length = max(max_length, right - left + 1)
    return max_length

# Test case
print(longest_unique_substring("abcabcbb"))  # Output: 3

Q25. How can you conduct a basic string compression?

Sample Answer: String compression replaces repeated characters with the character followed by the number of times it appears. For example, “aabcccccaaa” becomes “a2b1c5a3”. The following code demonstrates how can a string compression be carried out.

def compress_string(s):
    compressed = []
    count = 1
    for i in range(1, len(s)):
        if s[i] == s[i - 1]:
            count += 1
        else:
            compressed.append(s[i - 1] + str(count))
            count = 1
    compressed.append(s[-1] + str(count))
    return ''.join(compressed)

# Test case
print(compress_string("aabcccccaaa"))  # Output: "a2b1c5a3"

Q26. Create a code to find the common elements between two arrays.

Sample Answer: The common elements between two arrays can be found by employing Python’s set operations. Here’s the code to find the common elements between two arrays:

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

# Test case
print(intersection([1, 2, 2, 3], [2, 3, 4]))  # Output: [2, 3]

Q27. Write a program to detect if a linked list contains a cycle.

Sample Answer: To detect whether a linked list contains a cycle, we can use Floyd’s Cycle-Finding Algorithm. This algorithm uses two pointers, one moving slowly (one step at a time) and one moving quickly (two steps at a time). If there is a cycle, the two-pointers will eventually meet. Here’s how we can detect a cycle in a linked list.

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

def has_cycle(head):
    slow = fast = head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
        if slow == fast:
            return True
    return False

# Example usage:
# head = [3, 2, 0, -4] with a cycle; Output: True

Q28. How can you return the first unique character in a string?

Sample Answer: To find the first unique character in a string, we can use the Counter class from Python’s collections module to count the occurrences of each character. Then, we can iterate through the string to find the first character with a count of 1. We can return the first unique character in a string by following the code written in the table below.

from collections import Counter

def first_unique_char(s):
    counts = Counter(s)
    for i, char in enumerate(s):
        if counts[char] == 1:
            return i
    return -1

# Test case
print(first_unique_char("leetcode"))  # Output: 0

Q29. Write a program to find the element that appears more than n/2 times in an array.

Sample Answer: To find the element that appears more than n/2 times in an array, we can use the Boyer-Moore Voting Algorithm. This algorithm works by maintaining a candidate and a count. As we iterate through the array:

• If the count is 0, we set the current element as the new candidate.
• If the current element matches the candidate, we increase the count.
• If it doesn’t, we decrease the count.

Here is the code to demonstrate this:

def majority_element(nums):
    count = 0
    candidate = None
    for num in nums:
        if count == 0:
            candidate = num
        count += (1 if num == candidate else -1)
    return candidate

# Test case
print(majority_element([3, 2, 3]))  # Output: 3

Q30. How can you reverse words in a given string?

Sample Answer: To reverse the words in a string, we can split the string into a list of words, reverse the list, and then join the words back together with spaces. Here is the code for this task:

def reverse_words(s):
    return ' '.join(s.split()[::-1])

# Test case
print(reverse_words("hello world"))  # Output: "world hello"

TCS Coding Interview Questions and Answers for Experienced Candidates

For higher roles at TCS, interviewers usually look for experienced candidates who have an advanced understanding of technical principles, problem-solving abilities, and leadership skills. Here are some of the TCS advanced coding interview questions and answers:

Q31. Write a code to design and implement a Least Recently Used (LRU) cache.

Sample Answer: An LRU (Least Recently Used) Cache stores a fixed number of items. When the cache reaches its capacity, it removes the least recently used item to make room for new data. In this implementation, we use Python’s OrderedDict from the collections module to maintain the order of insertion. The move_to_end() method allows us to efficiently update the order when items are accessed. The following code illustrates how to design and implement a LRU cache.

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity: int):
        self.cache = OrderedDict()
        self.capacity = capacity

    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        self.cache.move_to_end(key)
        return self.cache[key]

    def put(self, key: int, value: int) -> None:
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)

# Example usage:
# cache = LRUCache(2)
# cache.put(1, 1)
# cache.put(2, 2)
# cache.get(1)       # Returns 1
# cache.put(3, 3)    # Evicts key 2
# cache.get(2)       # Returns -1

Q32. How can you find the Kth largest element in an unsorted array?

Sample Answer: To find the kth largest element in an unsorted array, we can use Python’s heapq library. The heapq.nlargest(k, nums) function returns the k largest elements from the list in sorted order. We can simply return the last element of this list to get the kth largest element. Here’s how we can find the Kth largest element in an unsorted array.

import heapq

def kth_largest(nums, k):
    return heapq.nlargest(k, nums)[-1]

# Test case
print(kth_largest([3, 2, 1, 5, 6, 4], 2))  # Output: 5

Q33. Write a program to implement trie data structure.

Sample Answer: A Trie is a tree-like data structure used to store strings, often used for tasks like autocomplete or spell checking. Each node represents a character, and the edges between nodes represent the sequence of characters in a string. Here is the code to implement a trie data structure:

class TrieNode:
    def __init__(self):
        self.children = {}
        self.is_end_of_word = False

class Trie:
    def __init__(self):
        self.root = TrieNode()

    def insert(self, word: str) -> None:
        node = self.root
        for char in word:
            if char not in node.children:
                node.children[char] = TrieNode()
            node = node.children[char]
        node.is_end_of_word = True

    def search(self, word: str) -> bool:
        node = self.root
        for char in word:
            if char not in node.children:
                return False
            node = node.children[char]
        return node.is_end_of_word

    def starts_with(self, prefix: str) -> bool:
        node = self.root
        for char in prefix:
            if char not in node.children:
                return False
            node = node.children[char]
        return True

# Example usage:
# trie = Trie()
# trie.insert("apple")
# trie.search("apple")    # Returns True
# trie.starts_with("app") # Returns True

Q34. Write a program to implement Dijkstra’s algorithm to find the shortest path in a graph.

Sample Answer: Dijkstra’s algorithm finds the shortest paths between nodes in a graph. It starts with the source node and repeatedly updates the shortest distance to its neighboring nodes. Here’s how we can implement Dijkstra’s algorithm to find the shortest path in a graph.

import heapq

def dijkstra(graph, start):
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    priority_queue = [(0, start)]
    
    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)
        
        if current_distance > distances[current_node]:
            continue
        
        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))
                
    return distances

# Test case
# graph = {'A': {'B': 1, 'C': 4}, 'B': {'A': 1, 'C': 2, 'D': 5}, 'C': {'A': 4, 'B': 2, 'D': 1}, 'D': {'B': 5, 'C': 1}}
# print(dijkstra(graph, 'A')) # Output: shortest paths from 'A' to all nodes

Q35. Write functions to serialize and deserialize a binary tree.

Sample Answer: Serialization converts a binary tree into a string format, which can be stored or transmitted. Deserialization converts the string back into a binary tree. The approach used in the sample involves Depth-First Search (DFS) to traverse the tree and capture the node values. The following function illustrates how we can serialize and deserialize a binary tree.

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def serialize(root):
    result = []
    def dfs(node):
        if not node:
            result.append("None")
            return
        result.append(str(node.val))
        dfs(node.left)
        dfs(node.right)
    
    dfs(root)
    return ','.join(result)

def deserialize(data):
    values = iter(data.split(','))
    def dfs():
        val = next(values)
        if val == "None":
            return None
        node = TreeNode(int(val))
        node.left = dfs()
        node.right = dfs()
        return node
    
    return dfs()

# Example usage:
# tree = TreeNode(1, TreeNode(2), TreeNode(3, TreeNode(4), TreeNode(5)))
# serialized = serialize(tree)
# deserialized = deserialize(serialized)

Q36. How can you find the median of two sorted arrays of different sizes?

Sample Answer: To find the median of two sorted arrays, we can merge them and then find the median of the combined array. This approach assumes merging is acceptable for simplicity. Here is the code to implement this:

def find_median_sorted_arrays(nums1, nums2):
    nums = sorted(nums1 + nums2)
    mid = len(nums) // 2
    return (nums[mid] + nums[~mid]) / 2

# Test case
print(find_median_sorted_arrays([1, 3], [2]))         # Output: 2.0
print(find_median_sorted_arrays([1, 2], [3, 4]))      # Output: 2.5

Q37. Create a code to find all possible paths between two nodes in a graph.

Sample Answer: This problem is about finding all paths from a start node to an end node in an undirected graph, which is represented using an adjacency list. The following code demonstrates the possible paths between two nodes in a graph.

def all_paths(graph, start, end, path=[]):
    path = path + [start]
    if start == end:
        return [path]
    paths = []
    for node in graph[start]:
        if node not in path:
            new_paths = all_paths(graph, node, end, path)
            for new_path in new_paths:
                paths.append(new_path)
    return paths

# Test case
# graph = {'A': ['B', 'C'], 'B': ['D'], 'C': ['D'], 'D': []}
# print(all_paths(graph, 'A', 'D')) # Output: [['A', 'B', 'D'], ['A', 'C', 'D']]

Q38. Given two words and a dictionary, find the shortest transformation sequence from start to end.

Sample Answer: In this problem, we need to find the shortest transformation sequence from a start word to an end word. Here, each word in the sequence must differ by exactly one letter, and each intermediate word must be in the given word list. Here’s how we can find the shortest transformation sequence from start to end.

from collections import deque

def word_ladder(beginWord, endWord, wordList):
    word_set = set(wordList)
    queue = deque([(beginWord, 1)])
    
    while queue:
        word, length = queue.popleft()
        if word == endWord:
            return length
        for i in range(len(word)):
            for char in 'abcdefghijklmnopqrstuvwxyz':
                next_word = word[:i] + char + word[i+1:]
                if next_word in word_set:
                    word_set.remove(next_word)
                    queue.append((next_word, length + 1))
    
    return 0

# Test case
# wordList = ["hot", "dot", "dog", "lot", "log", "cog"]
# print(word_ladder("hit", "cog", wordList))  # Output: 5

Q39. Write a program to find the kth smallest element in a Binary Search Tree.

Sample Answer: The BST property ensures that in an inorder traversal, the elements will be visited in ascending order. By performing an inorder traversal, we can find the kth smallest element. Here is the code to find the kth smallest element in a Binary Search Tree.

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def kth_smallest(root, k):
    def inorder(node):
        return inorder(node.left) + [node.val] + inorder(node.right) if node else []
    
    return inorder(root)[k - 1]

# Example usage:
# root = TreeNode(3, TreeNode(1, None, TreeNode(2)), TreeNode(4))
# print(kth_smallest(root, 1)) # Output: 1

Q40. How can you implement a Min-Heap data structure from scratch?

Sample Answer: A Min-Heap is a binary heap where the parent node is smaller than its children. The heap property ensures that the smallest element is always at the root. Here’s how we implement a Min-Heap data structure from scratch.

class MinHeap:
    def __init__(self):
        self.heap = []

    def insert(self, val):
        self.heap.append(val)
        self._heapify_up(len(self.heap) - 1)

    def extract_min(self):
        if len(self.heap) == 0:
            return None
        if len(self.heap) == 1:
            return self.heap.pop()
        root = self.heap[0]
        self.heap[0] = self.heap.pop()
        self._heapify_down(0)
        return root

    def _heapify_up(self, index):
        parent = (index - 1) // 2
        if index > 0 and self.heap[index] < self.heap[parent]:
            self.heap[index], self.heap[parent] = self.heap[parent], self.heap[index]
            self._

Pro Tip: Aside from the technical roles, TCS also offer jobs in the business process services domain. Check out our guide on BPS job interview questions at TCS.

Tips to Secure a Job at TCS

Like many other top consultancy firms, TCS has its standards of evaluation process for selecting top talent from the country. This requires thorough preparation and understanding of this process. Here are some top tips to help you secure a job at TCS.

1. Develop Key Technical Skills: Candidates must possess strong technical skills in programming languages such as C++, Java, SQL, or Python. A solid foundation in these areas is important, as technical proficiency is often assessed during interviews and tests.
2. Prepare for the TCS NQT: The TCS National Qualifier Test (NQT) is the primary gateway for recent graduates seeking employment at TCS. This test evaluates candidates on various skills, including:
   • Aptitude: Focuses on mathematical and reasoning-based questions.
   • Verbal Ability: Assesses language skills and comprehension.
   • Programming: Includes logical reasoning and coding exercises.
   • Domain-Specific Test: Specific exam questions depending on the applicant’s background.
3. Craft an Updated Resume: Use an updated resume showcasing projects or internships where you demonstrate problem-solving, leadership, or technical skills. Ensure that your experiences align with TCS’s services like cloud solutions, cybersecurity, and artificial intelligence.

Conclusion

To secure a position at Tata Consultancy Services, candidates should focus on building a strong foundation in coding. For different coding jobs like Java developer, Python developer, or Angular developer, a different set of coding questions are asked depending on the expertise level needed for the role. The sample TCS coding interview questions and answers will help you enhance your technical skills whether you are a fresher, mid-level candidate, or an advanced professional. Furthermore, consider checking out our comprehensive guide on TCS job interview questions with answers to help you ace your interview.

FAQs