## 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, second,sum;
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, 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");
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
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) {
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) {
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) {
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. }``````

``````#include<stdio.h>
#include<stdlib.h>
struct node
{
int data;
struct node *next;
};
{
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 *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 *newNode;
newNode = malloc(sizeof(struct node));
newNode->data = value;
}
void insertAtEnd(struct node* head, int value){
struct node *newNode;
newNode = malloc(sizeof(struct node));
newNode->data = value;
newNode->next = NULL;
while(temp->next != NULL){
temp = temp->next;
}
temp->next = newNode;
}
}
while(temp->next->next!=NULL){
temp = temp->next;
}
temp->next = NULL;
}
void deleteFromMiddle(struct node* head, int position){
int i;
for(i=2; inext != NULL) {
temp = temp->next;
}
}
temp->next = temp->next->next;
}
int main() {
/* Initialize nodes */
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;
display(head); // 1 --->2 --->3 --->
display(head); // 4 --->1 --->2 --->3 --->
display(head); // 1 --->2 --->3 --->
display(head); // 1 --->2 --->3 --->5 --->
display(head); // 1 --->2 --->3 --->
int position = 3;
display(head); // 1 --->2 --->10 --->3 --->
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 --->``````

``````#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
struct node {
int data;
int key;
struct node *next;
};
struct node *current = NULL;
bool isEmpty() {
}
int length() {
int length = 0;
//if list is empty
return 0;
}
length++;
current = current->next;
}
return length;
}
//insert link at the first location
void insertFirst(int key, int data) {
struct node *link = (struct node*) malloc(sizeof(struct node));
if (isEmpty()) {
} else {
//point it to old first node
//point first to new first node
}
}
//delete first item
struct node * deleteFirst() {
}
//mark next to first link as first
}
//display the list
void printList() {
printf("\n[ ");
//start from the beginning
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;
};
struct node *last = NULL;
struct node *current = NULL;
//is list empty
bool isEmpty() {
}
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
//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) {
struct node *link = (struct node*) malloc(sizeof(struct node));
if(isEmpty()) {
} else {
}
//point it to old first link
//point first to new first link
}
//insert link at the last location
void insertLast(int key, int data) {
struct node *link = (struct node*) malloc(sizeof(struct node));
if(isEmpty()) {
} else {
//mark old last node as prev of new link
}
//point last to new last node
}
//delete first item
struct node* deleteFirst() {
last = NULL;
} else {
}
}
//delete link at the last location
struct node* deleteLast() {
} else {
last->prev->next = NULL;
}
last = last->prev;
}
//delete a link with given key
struct node* delete(int key) {
struct node* previous = NULL;
//if list is empty
return NULL;
}
//navigate through list
while(current->key != key) {
//if it is last node
if(current->next == NULL) {
return NULL;
} else {
previous = current;
current = current->next;
}
}
//found a match, update the link
//change first to point to next link
} else {
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) {
//if list is empty
return false;
}
//navigate through list
while(current->key != key) {
//if it is last node
if(current->next == NULL) {
return false;
} else {
current = current->next;
}
}
struct node *newLink = (struct node*) malloc(sizeof(struct node));
if(current == last) {
} else {
}
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) ]
``````