TCS NQT April 2024 Coding Questions with Answers
TCS NQT off campus drive 2024 recently asked coding questions with answers.
TCS Coding Questions for Beginners The TCS Programming Test 2024 is unique and does not resemble the typical Coding Round Questions with Solutions. It stands apart from C programming. We have examined more than 100 TCS Programming Questions. Here, you will discover TCS Coding Questions that follow a similar pattern, these are the most frequent TCS Coding Questions that are consistently asked in the TCS Placement test. It’s crucial to thoroughly prepare the coding section to achieve a good score in the TCS NQT test. The programming languages that are permissible in the test include:
- C
- C++
- Java
- Python
- Perl
TCS Programming Queries In the TCS Exam, the second round (Advanced) includes TCS Coding queries. This coding segment consists of 2 problems and a time limit of 90 minutes is set. This round evaluates the coding abilities of the students and includes moderate to high-level Data Structure and Algorithm Questions. Students can review the various types of questions asked in the TCS Exam in the following part of the page.
Details: Coding Segment Number of Problems: 2 problems Time Duration: 90 minutes Complexity Level: medium
IMPORTANT NOTE:
- There will be no negative marking.
- You need to pass all test cases for atleast one code to get high chances of selection.
- TCS NQT Compiler is not that much of adaptive you need write code like how you write code in notepad.
- You will get rough papers in the exam and a calculator available on your Desktop Screen.
TCS NQT Coding Question 2024– April 26 – Slot 1 Q1
SUBARRAY-SUM-EQUALS-K
Given a sequence of integers, referred to as ‘nums’, and another integer ‘k’, the task is to find the total count of subarrays where the sum equals ‘k’. A subarray is defined as a continuous, non-empty sequence of elements within the array.
Example 1:
Input: nums = [1,1,1], k = 2
Output: 2
Example 2:
Input: nums = [1,2,3], k = 3
Output: 2
Constraints:
- The length of ‘nums’ is between 1 and 2 * 10^4 inclusive.
- Each element in ‘nums’ is between -1000 and 1000 inclusive.
- ‘k’ is between 10^7 and 10^7 inclusive.
def subarraySum(nums, k):
count = 0
for start in range(len(nums)):
sum = 0
for end in range(start, len(nums)):
sum += nums[end]
if sum == k:
count += 1
return count
def main():
nums = list(map(int, input("Enter the numbers separated by space: ").split()))
k = int(input("Enter the value of k: "))
print(subarraySum(nums, k))
if __name__ == "__main__":
main()
#include <iostream>
#include <vector>
using namespace std;
int subarraySum(vector<int>& nums, int k) {
int count = 0;
for (int start = 0; start < nums.size(); ++start) {
int sum = 0;
for (int end = start; end < nums.size(); ++end) {
sum += nums[end];
if (sum == k) {
++count;
}
}
}
return count;
}
int main() {
vector<int> nums;
int n, k, num;
cout << "Enter the number of elements: ";
cin >> n;
cout << "Enter the elements: ";
for (int i = 0; i < n; ++i) {
cin >> num;
nums.push_back(num);
}
cout << "Enter the value of k: ";
cin >> k;
cout << subarraySum(nums, k) << endl;
return 0;
}
import java.util.Scanner;
public class Main {
public static int subarraySum(int[] nums, int k) {
int count = 0;
for (int start = 0; start < nums.length; ++start) {
int sum = 0;
for (int end = start; end < nums.length; ++end) {
sum += nums[end];
if (sum == k) {
++count;
}
}
}
return count;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter the number of elements: ");
int n = scanner.nextInt();
int[] nums = new int[n];
System.out.println("Enter the elements: ");
for (int i = 0; i < n; ++i) {
nums[i] = scanner.nextInt();
}
System.out.print("Enter the value of k: ");
int k = scanner.nextInt();
System.out.println(subarraySum(nums, k));
}
}
TCS NQT Coding Question 2024– April 26 – Slot 1 Q2
Distinct Pathways
Distinct Pathways You are presented with a square grid of size N x N, where each cell is either obstructed (0) or accessible (1). A rat begins its journey from the top-left cell of the grid (0, 0) and aims to reach the bottom-right cell (N-1, N-1). The rat has the ability to move in four directions: upwards (U), downwards (D), leftwards (L), and rightwards ®. Your task is to write a program that identifies all the unique paths from the starting cell to the destination cell that the rat can traverse. The rat should only travel through accessible cells and should not revisit any cell.
Input Format: • The first line contains an integer, N, indicating the dimensions of the grid. • The following N lines each contain N integers, describing the rows of the grid where 1 signifies an accessible cell and 0 denotes an obstructed cell.
Output Format: • Print all the unique paths from the top-left to the bottom-right cell of the grid. Each path should be represented as a string of characters (U, D, L, R). Each path should be separated by a space.
def findPaths(grid):
paths = []
N = len(grid)
def backtrack(x, y, path):
if x == N-1 and y == N-1:
paths.append(path)
return
if x < 0 or x >= N or y < 0 or y >= N or grid[x][y] == 0:
return
grid[x][y] = 0 # Mark cell as visited
backtrack(x+1, y, path + 'D')
backtrack(x-1, y, path + 'U')
backtrack(x, y+1, path + 'R')
backtrack(x, y-1, path + 'L')
grid[x][y] = 1 # Reset cell
backtrack(0, 0, '')
return paths
# Input
N = int(input())
grid = []
for _ in range(N):
row = list(map(int, input().split()))
grid.append(row)
# Output
paths = findPaths(grid)
for path in paths:
print(path, end=' ')
#include <iostream>
#include <vector>
using namespace std;
void backtrack(vector<vector<int>>& grid, int x, int y, string path, vector<string>& paths) {
int N = grid.size();
if (x == N-1 && y == N-1) {
paths.push_back(path);
return;
}
if (x < 0 || x >= N || y < 0 || y >= N || grid[x][y] == 0) {
return;
}
grid[x][y] = 0; // Mark cell as visited
backtrack(grid, x+1, y, path + "D", paths);
backtrack(grid, x-1, y, path + "U", paths);
backtrack(grid, x, y+1, path + "R", paths);
backtrack(grid, x, y-1, path + "L", paths);
grid[x][y] = 1; // Reset cell
}
vector<string> findPaths(vector<vector<int>>& grid) {
vector<string> paths;
backtrack(grid, 0, 0, "", paths);
return paths;
}
int main() {
int N;
cin >> N;
vector<vector<int>> grid(N, vector<int>(N));
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
cin >> grid[i][j];
}
}
vector<string> paths = findPaths(grid);
for (const auto& path : paths) {
cout << path << " ";
}
return 0;
}
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class UniquePaths {
public static List<String> findPaths(int[][] grid) {
List<String> paths = new ArrayList<>();
backtrack(grid, 0, 0, "", paths);
return paths;
}
private static void backtrack(int[][] grid, int x, int y, String path, List<String> paths) {
int N = grid.length;
if (x == N-1 && y == N-1) {
paths.add(path);
return;
}
if (x < 0 || x >= N || y < 0 || y >= N || grid[x][y] == 0) {
return;
}
grid[x][y] = 0; // Mark cell as visited
backtrack(grid, x+1, y, path + "D", paths);
backtrack(grid, x-1, y, path + "U", paths);
backtrack(grid, x, y+1, path + "R", paths);
backtrack(grid, x, y-1, path + "L", paths);
grid[x][y] = 1; // Reset cell
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int N = scanner.nextInt();
int[][] grid = new int[N][N];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
grid[i][j] = scanner.nextInt();
}
}
List<String> paths = findPaths(grid);
for (String path : paths) {
System.out.print(path + " ");
}
scanner.close();
}
}
TCS NQT Coding Question 2024– April 26 – Slot 2 Q1
Problem Statement:
1.Given two integers, M and N, calculate the sum of the cubes of all integers from M to N inclusive. If M is greater than N, the result should be zero or an appropriate message should be displayed.
Input Format:
The input will consist of two integers, M and N, where M and N could be any integer, positive or negative.
Output Format:
Output a single integer representing the sum of the cubes of all integers from M to N inclusive.
Example:
Input:
M = 2 N = 4
Output:
63
Explanation: The sum of the cubes of 2, 3, and 4 is 8 + 27 + 64 = 99.
def sum_of_cubes(M, N):
if M > N:
return "M should be less than or equal to N"
else:
return sum(i**3 for i in range(M, N+1))
# Input
M, N = map(int, input().split())
# Output
print(sum_of_cubes(M, N))
#include <iostream>
using namespace std;
int sum_of_cubes(int M, int N) {
if (M > N) {
cout << "M should be less than or equal to N";
return 0;
} else {
int sum = 0;
for (int i = M; i <= N; ++i) {
sum += i * i * i;
}
return sum;
}
}
int main() {
int M, N;
cin >> M >> N;
cout << sum_of_cubes(M, N);
return 0;
}
import java.util.Scanner;
public class SumOfCubes {
public static int sumOfCubes(int M, int N) {
if (M > N) {
System.out.println("M should be less than or equal to N");
return 0;
} else {
int sum = 0;
for (int i = M; i <= N; i++) {
sum += i * i * i;
}
return sum;
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int M = scanner.nextInt();
int N = scanner.nextInt();
System.out.println(sumOfCubes(M, N));
scanner.close();
}
}
TCS NQT Coding Question 2024– April 26 – Slot 2 Q2
2.Problem Statement:
You are provided with a list of sales entries, each entry containing three fields: the name of the item, the price per unit, and the number of units sold. An item can appear multiple times in the list with different units sold each time. Your task is to compute the total sales, the average sales per entry, and identify the best-selling item based on total revenue generated from that item.
Input Format:
- You will be given a list of tuples, each tuple containing a string and two floats. The string represents the item name, the first float represents the price per unit, and the second float represents the number of units sold.
Output Format:
- Print the total sales rounded to two decimal places.
- Print the average sales per entry rounded to two decimal places.
- Print the name of the best-selling item based on the total sales.
Constraints:
- The list will have at least one entry.
- The price per unit will be a positive decimal number.
- The units sold will be a non-negative integer
Input:
[ (“Tomato”, 2.0, 3),(“Potato”, 1.5, 10), (“Tomato”, 2.0, 2),(“Carrot”, 1.0, 8),(“Potato”, 1.5, 5)]
Output:
Total Sales: $47.50
Average Sales: $9.50
Best Selling Item: Potato
Explanation:
The total sales are calculated as follows: (2.0×3)+(1.5×10)+(2.0×2)+(1.0×8)+ (1.5×5)=6+15+4+8+7.5-40.5.
(2.0×3)+(1.5×10)+(2.0×2)+(1.0×8)+(1.5×5)=6+15+4+8+7.5-40.5
Average sales per entry: 40.5/5-9.5. 40.5/5-9.5
Best selling item: “Potato” generates the most sales ($22.5 from selling 15 units at $1.5 each
def calculate_sales(entries):
total_sales = sum(price * quantity for _, price, quantity in entries)
average_sales = total_sales / len(entries)
best_selling_item = max(entries, key=lambda x: x[1] * x[2])[0]
return total_sales, average_sales, best_selling_item
# Input
entries = [("Tomato", 2.0, 3), ("Potato", 1.5, 10), ("Tomato", 2.0, 2), ("Carrot", 1.0, 8), ("Potato", 1.5, 5)]
# Output
total_sales, average_sales, best_selling_item = calculate_sales(entries)
print(f"Total Sales: ${total_sales:.2f}")
print(f"Average Sales: ${average_sales:.2f}")
print(f"Best Selling Item: {best_selling_item}")
#include <iostream>
#include <vector>
#include <algorithm>
#include <iomanip>
using namespace std;
struct Entry {
string item_name;
float price_per_unit;
int units_sold;
};
tuple<float, float, string> calculateSales(const vector<Entry>& entries) {
float total_sales = 0;
for (const Entry& entry : entries) {
total_sales += entry.price_per_unit * entry.units_sold;
}
float average_sales = total_sales / entries.size();
string best_selling_item;
float max_revenue = 0;
for (const Entry& entry : entries) {
float revenue = entry.price_per_unit * entry.units_sold;
if (revenue > max_revenue) {
max_revenue = revenue;
best_selling_item = entry.item_name;
}
}
return make_tuple(total_sales, average_sales, best_selling_item);
}
int main() {
vector<Entry> entries = {{"Tomato", 2.0, 3},
{"Potato", 1.5, 10},
{"Tomato", 2.0, 2},
{"Carrot", 1.0, 8},
{"Potato", 1.5, 5}};
auto result = calculateSales(entries);
cout << fixed << setprecision(2);
cout << "Total Sales: $" << get<0>(result) << endl;
cout << "Average Sales: $" << get<1>(result) << endl;
cout << "Best Selling Item: " << get<2>(result) << endl;
return 0;
}
import java.util.ArrayList;
import java.util.List;
class Entry {
String itemName;
float pricePerUnit;
int unitsSold;
public Entry(String itemName, float pricePerUnit, int unitsSold) {
this.itemName = itemName;
this.pricePerUnit = pricePerUnit;
this.unitsSold = unitsSold;
}
}
public class SalesCalculator {
public static void main(String[] args) {
List<Entry> entries = new ArrayList<>();
entries.add(new Entry("Tomato", 2.0f, 3));
entries.add(new Entry("Potato", 1.5f, 10));
entries.add(new Entry("Tomato", 2.0f, 2));
entries.add(new Entry("Carrot", 1.0f, 8));
entries.add(new Entry("Potato", 1.5f, 5));
float totalSales = 0;
for (Entry entry : entries) {
totalSales += entry.pricePerUnit * entry.unitsSold;
}
float averageSales = totalSales / entries.size();
String bestSellingItem = "";
float maxRevenue = 0;
for (Entry entry : entries) {
float revenue = entry.pricePerUnit * entry.unitsSold;
if (revenue > maxRevenue) {
maxRevenue = revenue;
bestSellingItem = entry.itemName;
}
}
System.out.printf("Total Sales: $%.2f\n", totalSales);
System.out.printf("Average Sales: $%.2f\n", averageSales);
System.out.println("Best Selling Item: " + bestSellingItem);
}
}
TCS NQT Coding Question 2024– April 29 – Slot 1 Q1
Problem Statement 1
Given an integer, we need to find the sum of values of that table.
Input:10
Output:550
Explanation: 10*1+10*2+…..10*10
def sum_of_table_values(n):
return sum(n * i for i in range(1, n+1))
# Input
n = int(input("Input: "))
# Output
print("Output:", sum_of_table_values(n))
#include <iostream>
using namespace std;
int sumOfTableValues(int n) {
int sum = 0;
for (int i = 1; i <= n; ++i) {
sum += n * i;
}
return sum;
}
int main() {
int n;
cout << "Input: ";
cin >> n;
cout << "Output: " << sumOfTableValues(n) << endl;
return 0;
}
import java.util.Scanner;
public class TableSum {
public static int sumOfTableValues(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += n * i;
}
return sum;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Input: ");
int n = scanner.nextInt();
System.out.println("Output: " + sumOfTableValues(n));
scanner.close();
}
}
TCS NQT Coding Question 2024– April 29 – Slot 1 Q2
Problem Statement 2:
Given an array and a integer k.we need to find the maximum element in each of the contiguous subarrays.
Input: 247163
K=3
Output:7776
The subarrays will be [2,4,7], [4,7,1],[7,1,6] and [1,6,3]. The maximum numbers from the subarrays are
7 7 7 6
from collections import deque
def max_in_subarrays(nums, k):
result = []
window = deque()
for i, num in enumerate(nums):
while window and nums[window[-1]] < num:
window.pop()
window.append(i)
if i - window[0] >= k:
window.popleft()
if i >= k - 1:
result.append(nums[window[0]])
return result
# Input
nums = list(map(int, input().strip()))
k = int(input().strip())
# Output
print(max_in_subarrays(nums, k))
#include <iostream>
#include <vector>
#include <deque>
using namespace std;
vector<int> maxInSubarrays(const vector<int>& nums, int k) {
vector<int> result;
deque<int> window;
for (int i = 0; i < nums.size(); ++i) {
while (!window.empty() && nums[window.back()] < nums[i]) {
window.pop_back();
}
window.push_back(i);
if (i - window.front() >= k) {
window.pop_front();
}
if (i >= k - 1) {
result.push_back(nums[window.front()]);
}
}
return result;
}
int main() {
string input;
cin >> input;
int k;
cin >> k;
vector<int> nums;
for (char c : input) {
nums.push_back(c - '0');
}
vector<int> result = maxInSubarrays(nums, k);
for (int num : result) {
cout << num << " ";
}
cout << endl;
return 0;
}
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Scanner;
public class MaxInSubarrays {
public static int[] maxInSubarrays(int[] nums, int k) {
int[] result = new int[nums.length - k + 1];
Deque<Integer> window = new ArrayDeque<>();
for (int i = 0; i < nums.length; i++) {
while (!window.isEmpty() && nums[window.peekLast()] < nums[i]) {
window.pollLast();
}
window.offerLast(i);
if (i - window.peekFirst() >= k) {
window.pollFirst();
}
if (i >= k - 1) {
result[i - k + 1] = nums[window.peekFirst()];
}
}
return result;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String input = scanner.next();
int k = scanner.nextInt();
int[] nums = new int[input.length()];
for (int i = 0; i < input.length(); i++) {
nums[i] = input.charAt(i) - '0';
}
int[] result = maxInSubarrays(nums, k);
for (int num : result) {
System.out.print(num + " ");
}
scanner.close();
}
}
TCS NQT Coding Question 2024– April 29 – Slot 2 Q1
Problem Statement 1
Write a function called ‘sum fibonacci that takes a single integer ‘n’ (where 1 <= n <= 50 ) as input and returns the sum of the first ‘n terms of the Fibonacci sequence.
The Fibonacci sequence is defined as follows:
F(0) = 0
F(1) = 1
F(n) = F(n – 1) + F(n – 2) for n >= 2
Your task is to calculate the sum of the first ‘n’ Fibonacci numbers, F (0) through F(n-1), and return this sum.
Example
Input: n= 5
Output: 7
Explanation : The first 5 fibonacci numbers :0,1,1,2,3 their sum 0+1+1+2+3=7
def sum_fibonacci(n):
if n <= 0:
return 0
elif n == 1:
return 0
elif n == 2:
return 1
else:
fib = [0] * n
fib[1] = 1
for i in range(2, n):
fib[i] = fib[i - 1] + fib[i - 2]
return sum(fib)
# Input
n = int(input())
# Output
print(sum_fibonacci(n))
#include <iostream>
#include <vector>
using namespace std;
int sumFibonacci(int n) {
if (n <= 0) {
return 0;
} else if (n == 1) {
return 0;
} else if (n == 2) {
return 1;
} else {
vector<int> fib(n);
fib[1] = 1;
for (int i = 2; i < n; ++i) {
fib[i] = fib[i - 1] + fib[i - 2];
}
int sum = 0;
for (int i = 0; i < n; ++i) {
sum += fib[i];
}
return sum;
}
}
int main() {
int n;
cin >> n;
cout << sumFibonacci(n) << endl;
return 0;
}
import java.util.Scanner;
public class Fibonacci {
public static int sumFibonacci(int n) {
if (n <= 0) {
return 0;
} else if (n == 1) {
return 0;
} else if (n == 2) {
return 1;
} else {
int[] fib = new int[n];
fib[1] = 1;
for (int i = 2; i < n; i++) {
fib[i] = fib[i - 1] + fib[i - 2];
}
int sum = 0;
for (int i = 0; i < n; i++) {
sum += fib[i];
}
return sum;
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
System.out.println(sumFibonacci(n));
scanner.close();
}
}
TCS NQT Coding Question 2024– April 29 – Slot 2 Q2
Problem Statement 2:
Given an integer array arr, return the number of distinct bitwise ORs of all the non-empty subarrays of arr.The bitwise OR of a subarray is the bitwise OR of each integer in the subarray. The bitwise OR of a subarray of one integer is that integer.A subarray is a contiguous non-empty sequence of elements within an array.
Example 1:
Input: arr= [0]
Explanation: There is only one possible result: 0.
Output: 1
Example 2:
Input: arr [1,1,2]
Output: 3
Explanation: The possible subarrays are [1], [1], [2], [1, 1], [1, 2], [1, 1, 2].These yield the results 1, 1, 2, 1, 3, 3. There are 3 unique values, so the answer is 3.
Example 3:
Input: arr = [1,2,4]
Output: 6
Explanation: The possible results are 1, 2, 3, 4, 6, and 7.
def count_distinct_bitwise_ORs(arr):
distinct_ORs = set()
current_ORs = {0}
for num in arr:
current_ORs = {num | x for x in current_ORs} | {num}
distinct_ORs |= current_ORs
return len(distinct_ORs)
# Input
arr = list(map(int, input("Enter the array elements separated by space: ").split()))
# Output
print("Output:", count_distinct_bitwise_ORs(arr))
#include <iostream>
#include <unordered_set>
#include <vector>
using namespace std;
int countDistinctBitwiseORs(vector<int>& arr) {
unordered_set<int> distinctORs, currentORs = {0};
for (int num : arr) {
unordered_set<int> newCurrentORs;
for (int x : currentORs) {
newCurrentORs.insert(num | x);
}
newCurrentORs.insert(num);
currentORs = newCurrentORs;
distinctORs.insert(currentORs.begin(), currentORs.end());
}
return distinctORs.size();
}
int main() {
vector<int> arr;
cout << "Enter the number of elements in the array: ";
int n;
cin >> n;
cout << "Enter the array elements: ";
for (int i = 0; i < n; ++i) {
int num;
cin >> num;
arr.push_back(num);
}
cout << "Output: " << countDistinctBitwiseORs(arr) << endl;
return 0;
}
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class DistinctBitwiseORs {
public static int countDistinctBitwiseORs(int[] arr) {
Set<Integer> distinctORs = new HashSet<>();
Set<Integer> currentORs = new HashSet<>();
currentORs.add(0);
for (int num : arr) {
Set<Integer> newCurrentORs = new HashSet<>();
for (int x : currentORs) {
newCurrentORs.add(num | x);
}
newCurrentORs.add(num);
currentORs = newCurrentORs;
distinctORs.addAll(currentORs);
}
return distinctORs.size();
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter the number of elements in the array: ");
int n = scanner.nextInt();
int[] arr = new int[n];
System.out.println("Enter the array elements: ");
for (int i = 0; i < n; i++) {
arr[i] = scanner.nextInt();
}
System.out.println("Output: " + countDistinctBitwiseORs(arr));
scanner.close();
}
}