TCS NQT Coding Questions Solutions

What is the TCS NQT Test?

TCS NQT is one of the best exams for job seekers who are looking for a software job in a reputed company. if you clear this exam then you can apply for job interviews directly with top companies. like Tata Elxsi, Tata consultancy, Mphasis upgrade, and many more. but the question that how to clear this exam. if you want to clear this exam. you have to prepare Aptitude and coding. Most of the candidates prepare aptitude well but coding does not. So In this article, we are going to give you the most frequently asked coding questions in the TCS NQT test with solutions.

Frequently Asked Coding Questions and Solutions in TCS NQT Test.

Q1. Addition Of Two Matrices In C:

1. #include <stdio.h>
2.
3. int main()
4. {
5. int m, n, c, d, first[10][10], second[10][10],sum[10][10]; 
6.
7. printf("Enter the number of rows and columns ofmatrix\n");
8. scanf("%d%d", &m, &n);
9. printf("Enter the elements of first matrix\n");
10.
11. for (c = 0; c < m; c++) 
12. for (d = 0; d < n; d++)
13. scanf("%d", &first[c][d]);
14.
15. printf("Enter the elements of second matrix\n");
16.
17. for (c = 0; c < m; c++) 
18. for (d = 0 ; d < n; d++)
19. scanf("%d", &second[c][d]);
20.
21. printf("Sum of entered matrices:-\n");
22.
23. for (c = 0; c < m; c++) { 
24. for (d = 0 ; d < n; d++) {
25. sum[c][d] = first[c][d] + second[c][d];
26. printf("%d\t", sum[c][d]);
27. }
28. printf("\n");
29. } 
30.
31. return 0;
32. }
OUTPUT:-

Enter the number of rows and columns ofmatrix
2
2
Enter the elements of first matrix
1 2
3 4
Enter the elements of second matrix
5 6
2 1
Sum of entered matrices:-
6 8
5 5

Q 2. Program to find the average of n (n < 10) numbers using arrays

#include <stdio.h> 
int main()
{
int marks[10], i, n, sum = 0, average; 
printf("Enter n: ");
scanf("%d", &n); 
for(i=0; i<n; ++i)
{
printf("Enter number%d: ",i+1); 
scanf("%d", &marks[i]);
sum += marks[i];
}
average = sum/n; 
printf("Average = %d", average);
return 0;
}


Output:
Enter n: 5
Enter number1: 45
Enter number2: 35
Enter number3: 38
Enter number4: 31
Enter number5: 49
Average = 39

Q3. C program To Implement Linked List

1. #include <stdio.h>
2. #include <stdlib.h>
3.
4. struct node {
5. int data;
6. struct node *next;
7. };
8.
9. struct node *start = NULL;
10. void insert_at_begin(int);
11. void insert_at_end(int);
12. void traverse();
13. void delete_from_begin();
14. void delete_from_end();
15. int count = 0;
16.
17. int main () {
18. int input, data;
19.
20. for (;;) {
21. printf("1. Insert an element at beginning of linked list.\n");
22. printf("2. Insert an element at end of linked list.\n");
23. printf("3. Traverse linked list.\n");
24. printf("4. Delete element from beginning.\n");
25. printf("5. Delete element from end.\n");
26. printf("6. Exit\n");
27.
28. scanf("%d", &input);
29.
30. if (input == 1) {
31. printf("Enter value of element\n");
32. scanf("%d", &data);
33. insert_at_begin(data);
34. }
35. else if (input == 2) {
36. printf("Enter value of element\n");
37. scanf("%d", &data);
38. insert_at_end(data);
39. }
40. else if (input == 3)
41. traverse();
42. else if (input == 4)
43. delete_from_begin();
44. else if (input == 5)
45. delete_from_end();
46. else if (input == 6)
47. break;
48. else
49. printf("Please enter valid input.\n");
50. } 
51.
52. return 0;
53. } 
54.
55. void insert_at_begin(int x) {
56. struct node *t;
57.
58. t = (struct node*)malloc(sizeof(struct node));
59. count++;
60.
61. if (start == NULL) {
62. start = t;
63. start->data = x;
64. start->next = NULL;
65. return;
66. } 
67.
68. t->data = x;
69. t->next = start;
70. start = t;
71. } 
72.
73. void insert_at_end(int x) {
74. struct node *t, *temp;
75.
76. t = (struct node*)malloc(sizeof(struct node));
77. count++;
78.
79. if (start == NULL) {
80. start = t;
81. start->data = x;
82. start->next = NULL;
83. return;
84. } 
85.
86. temp = start;
87.
88. while (temp->next != NULL)
89. temp = temp->next;
90.
91. temp->next = t;
92. t->data = x;
93. t->next = NULL;
94. } 
95.
96. void traverse() {
97. struct node *t;
98.
99. t = start;
100.
101. if (t == NULL) {
102. printf("Linked list is empty.\n");
103. return;
104. } 
105.
106. printf("There are %d elements in linked list.\n", count);
107.
108. while (t->next != NULL) {
109. printf("%d\n", t->data);
110. t = t->next;
111. }
112. printf("%d\n", t->data);
113. } 
114.
115. void delete_from_begin() {
116. struct node *t;
117. int n;
118.
119. if (start == NULL) {
120. printf("Linked list is already empty.\n");
121. return;
122. } 
123.
124. n = start->data;
125. t = start->next;
126. free(start);
127. start = t;
128. count--;
129.
130. printf("%d deleted from beginning successfully.\n", n);
131. } 
132.
133. void delete_from_end() {
134. struct node *t, *u;
135. int n;
136.
137. if (start == NULL) {
138. printf("Linked list is already empty.\n");
139. return;
140. } 
141.
142. count--;
143.
144. if (start->next == NULL) {
145. n = start->data;
146. free(start);
147. start = NULL;
148. printf("%d deleted from end successfully.\n", n);
149. return;
150. } 
151.
152. t = start;
153.
154. while (t->next != NULL) {
155. u = t;
156. t = t->next;
157. } 
158.
159. n = t->data;
160. u->next = NULL;
161. free(t);
162.
163. printf("%d deleted from end successfully.\n", n);
164. }

Q4. Operations On Linked List

#include<stdio.h> 
#include<stdlib.h>
struct node
{
int data;
struct node *next;
};
void display(struct node* head)
{
struct node *temp = head; 
printf("\n\nList elements are - \n"); 
while(temp != NULL)
{
printf("%d --->",temp->data); 
temp = temp->next;
}
}
void insertAtMiddle(struct node *head, int position, int value) { 
struct node *temp = head;
struct node *newNode;
newNode = malloc(sizeof(struct node)); 
newNode->data = value;
int i;
for(i=2; inext != NULL) { 
temp = temp->next;
}
}
newNode->next = temp->next; 
temp->next = newNode;
}
void insertAtFront(struct node** headRef, int value) { 
struct node* head = *headRef;
struct node *newNode;
newNode = malloc(sizeof(struct node)); 
newNode->data = value;
newNode->next = head; 
head = newNode;
*headRef = head;
}
void insertAtEnd(struct node* head, int value){ 
struct node *newNode;
newNode = malloc(sizeof(struct node)); 
newNode->data = value;
newNode->next = NULL;
struct node *temp = head; 
while(temp->next != NULL){
temp = temp->next;
}
temp->next = newNode;
}
void deleteFromFront(struct node** headRef){ 
struct node* head = *headRef;
head = head->next;
*headRef = head;
}
void deleteFromEnd(struct node* head){ 
struct node* temp = head; 
while(temp->next->next!=NULL){
temp = temp->next;
}
temp->next = NULL;
}
void deleteFromMiddle(struct node* head, int position){ 
struct node* temp = head;
int i;
for(i=2; inext != NULL) { 
temp = temp->next;
}
}
temp->next = temp->next->next;
}
int main() {
/* Initialize nodes */ 
struct node *head; 
struct node *one = NULL; 
struct node *two = NULL;
struct node *three = NULL;
/* Allocate memory */
one = malloc(sizeof(struct node)); 
two = malloc(sizeof(struct node)); 
three = malloc(sizeof(struct node));
/* Assign data values */ 
one->data = 1;
two->data = 2;
three->data = 3;
/* Connect nodes */ 
one->next = two; 
two->next = three; 
three->next = NULL;
/* Save address of first node in head */ 
head = one;
display(head); // 1 --->2 --->3 --->
insertAtFront(&head, 4);
display(head); // 4 --->1 --->2 --->3 --->
deleteFromFront(&head); 
display(head); // 1 --->2 --->3 --->
insertAtEnd(head, 5);
display(head); // 1 --->2 --->3 --->5 --->
deleteFromEnd(head);
display(head); // 1 --->2 --->3 --->
int position = 3; 
insertAtMiddle(head, position, 10);
display(head); // 1 --->2 --->10 --->3 --->
deleteFromMiddle(head, position); 
display(head); // 1 --->2 --->3 --->
}
Output:
List elements are -
1 --->2 --->3 --->
List elements are -
4 --->1 --->2 --->3 --->
List elements are -
1 --->2 --->3 --->
List elements are -
1 --->2 --->3 --->5 --->
List elements are -
1 --->2 --->3 --->
List elements are -
1 --->2 --->10 --->3 --->
List elements are -
1 --->2 --->3 --->

Q5. Circular Linked List

#include <stdio.h> 
#include <string.h> 
#include <stdlib.h> 
#include <stdbool.h>
struct node { 
int data; 
int key;
struct node *next;
};
struct node *head = NULL; 
struct node *current = NULL;
bool isEmpty() {
return head == NULL;
}
int length() {
int length = 0;
//if list is empty 
if(head == NULL) {
return 0;
}
current = head->next;
while(current != head) { 
length++;
current = current->next;
}
return length;
}
//insert link at the first location 
void insertFirst(int key, int data) {
//create a link
struct node *link = (struct node*) malloc(sizeof(struct node)); 
link->key = key;
link->data = data;
if (isEmpty()) { 
head = link;
head->next = head;
} else {
//point it to old first node 
link->next = head;
//point first to new first node 
head = link;
}
}
//delete first item
struct node * deleteFirst() {
//save reference to first link 
struct node *tempLink = head;
if(head->next == head) { 
head = NULL;
return tempLink;
}
//mark next to first link as first 
head = head->next;
//return the deleted link 
return tempLink;
}
//display the list 
void printList() {
struct node *ptr = head; 
printf("\n[ ");
//start from the beginning 
if(head != NULL) {
while(ptr->next != ptr) {
printf("(%d,%d) ",ptr->key,ptr->data); 
ptr = ptr->next;
}
}
printf(" ]");
}
void main() { 
insertFirst(1,10); 
insertFirst(2,20); 
insertFirst(3,30); 
insertFirst(4,1); 
insertFirst(5,40); 
insertFirst(6,56);
printf("Original List: ");
//print list 
printList();
while(!isEmpty()) {
struct node *temp = deleteFirst(); 
printf("\nDeleted value:"); 
printf("(%d,%d) ",temp->key,temp->data);
}
printf("\nList after deleting all items: "); 
printList();
}

Output:
Original List:
[ (6,56) (5,40) (4,1) (3,30) (2,20) ]
Deleted value:(6,56) 
Deleted value:(5,40) 
Deleted value:(4,1) 
Deleted value:(3,30) 
Deleted value:(2,20) 
Deleted value:(1,10)
List after deleting all items: 
[ ]

Q6.

. #include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
struct node { 
int data; 
int key;
struct node *next; 
struct node *prev;
};
//this link always point to first Link 
struct node *head = NULL;
//this link always point to last Link 
struct node *last = NULL;
struct node *current = NULL;
//is list empty 
bool isEmpty() {
return head == NULL;
}
int length() {
int length = 0;
struct node *current;
for(current = head; current != NULL; current = current->next){ 
length++;
}
return length;
}
//display the list in from first to last 
void displayForward() {
//start from the beginning 
struct node *ptr = head;
//navigate till the end of the list 
printf("\n[ ");
while(ptr != NULL) {
printf("(%d,%d) ",ptr->key,ptr->data); 
ptr = ptr->next;
}
printf(" ]");
}
//display the list from last to first 
void displayBackward() {
//start from the last 
struct node *ptr = last;
//navigate till the start of the list 
printf("\n[ ");
while(ptr != NULL) {
//print data
printf("(%d,%d) ",ptr->key,ptr->data);
//move to next item 
ptr = ptr ->prev;
}
}
//insert link at the first location 
void insertFirst(int key, int data) {
//create a link
struct node *link = (struct node*) malloc(sizeof(struct node)); 
link->key = key;
link->data = data;
if(isEmpty()) {
//make it the last link 
last = link;
} else {
//update first prev link 
head->prev = link;
}
//point it to old first link 
link->next = head;
//point first to new first link 
head = link;
}
//insert link at the last location 
void insertLast(int key, int data) {
//create a link
struct node *link = (struct node*) malloc(sizeof(struct node)); 
link->key = key;
link->data = data;
if(isEmpty()) {
//make it the last link 
last = link;
} else {
//make link a new last link 
last->next = link;
//mark old last node as prev of new link 
link->prev = last;
}
//point last to new last node
last = link;
}
//delete first item
struct node* deleteFirst() {
//save reference to first link 
struct node *tempLink = head;
//if only one link 
if(head->next == NULL){
last = NULL;
} else {
head->next->prev = NULL;
}
head = head->next;
//return the deleted link 
return tempLink;
}
//delete link at the last location
struct node* deleteLast() {
//save reference to last link 
struct node *tempLink = last;
//if only one link 
if(head->next == NULL) {
head = NULL;
} else {
last->prev->next = NULL;
}
last = last->prev;
//return the deleted link 
return tempLink;
}
//delete a link with given key 
struct node* delete(int key) {
//start from the first link 
struct node* current = head; 
struct node* previous = NULL;
//if list is empty 
if(head == NULL) { 
return NULL;
}
//navigate through list 
while(current->key != key) {
//if it is last node
if(current->next == NULL) { 
return NULL;
} else {
//store reference to current link 
previous = current;
//move to next link 
current = current->next;
}
}
//found a match, update the link 
if(current == head) {
//change first to point to next link 
head = head->next;
} else {
//bypass the current link
current->prev->next = current->next;
}
if(current == last) {
//change last to point to prev link 
last = current->prev;
} else {
current->next->prev = current->prev;
}
return current;
}
bool insertAfter(int key, int newKey, int data) {
//start from the first link 
struct node *current = head;
//if list is empty 
if(head == NULL) {
return false;
}
//navigate through list 
while(current->key != key) {
//if it is last node 
if(current->next == NULL) {
return false;
} else {
//move to next link 
current = current->next;
}
}
//create a link
struct node *newLink = (struct node*) malloc(sizeof(struct node)); 
newLink->key = newKey;
newLink->data = data;
if(current == last) { 
newLink->next = NULL; 
last = newLink;
} else {
newLink->next = current->next; 
current->next->prev = newLink;
}
newLink->prev = current; 
current->next = newLink; 
return true;
}
void main() { 
insertFirst(1,10); 
insertFirst(2,20);
insertFirst(3,30); 
insertFirst(4,1); 
insertFirst(5,40); 
insertFirst(6,56);
printf("\nList (First to Last): "); 
displayForward();
printf("\n");
printf("\nList (Last to first): "); 
displayBackward();
printf("\nList , after deleting first record: "); 
deleteFirst();
displayForward();
printf("\nList , after deleting last record: "); 
deleteLast();
displayForward();
printf("\nList , insert after key(4) : "); 
insertAfter(4,7, 13);
displayForward();
printf("\nList , after delete key(4) : "); 
delete(4);
displayForward();
}
Output:
List (First to Last):
[ (6,56) (5,40) (4,1) (3,30) (2,20) (1,10) ]
List (Last to first):
[ (1,10) (2,20) (3,30) (4,1) (5,40) (6,56) ]
List , after deleting first record:
[ (5,40) (4,1) (3,30) (2,20) (1,10) ]
List , after deleting last record: 
[ (5,40) (4,1) (3,30) (2,20) ]
List , insert after key(4) :
[ (5,40) (4,1) (4,13) (3,30) (2,20) ]
List , after delete key(4) :
[ (5,40) (4,13) (3,30) (2,20) ]
Updated: November 24, 2022 — 1:24 pm

Leave a Reply

Your email address will not be published. Required fields are marked *