If you're planning to sit for the TCS CodeVita placement exam, it's essential to know the best practices and exam advice to ensure that you are well-prepared for the competition. You can start by practicing with the TCS CodeVita placement exam practice questions and familiarizing yourself with the exam pattern and syllabus.
The TCS CodeVita exam is known for its challenging questions that assess the candidate's analytical and coding skills. The competition aims to identify the top-performing coders globally and offer them exciting career opportunities with Tata Consultancy Services.
The TCS CodeVita placement exam registration process is straightforward and can be completed online. To crack the exam, you need to be well-versed in coding, algorithms, and data structures. You can also seek guidance from experienced coders and participate in coding communities to enhance your skills.
It's important to note that cheating in the TCS CodeVita placement exam is not possible and not advisable. TCS has robust anti-cheating measures in place to ensure a fair and transparent competition for all participants.
So, focus on improving your coding skills and acing the TCS CodeVita placement exam to stand a chance to win exciting prizes and career opportunities. The primary goal of this contest is to identify and recognize top-performing coders, and offer them the chance to pursue career opportunities with Tata Consultancy Services.
There are some exciting prizes to be won:
Quantitative Aptitude:
Logical Reasoning:
Tech Test:
English - Verbal:
Okay, now move further to the exam pattern and other contest details. CodeVita is an online coding contest that consists of 3 major rounds: Pre-Qualifier Round, Qualifier Round, and Grand Finale.
1. Pre-Qualifier Round: It will be an online coding contest in which the participants need to solve the questions within 6 hours. Meanwhile, there will two zonal rounds for the Pre-Qualifier Stage in India. Moreover, the participants will be tagged to a particular contest zone based on the form details.
2. Qualifier Round: Once you’ll get done with Pre-Qualifier rounds, then the Qualifier Round will take place on a particular day for both Indian and other students. The top performers in the zonal rounds will be promoted to this qualifier round. In this round, each participant is provided with 6 hours to solve the questions.
3. Grand Finale: It will be the final round where the top performers from the second round (Qualifier round) will participate. It will be held in one of the TCSL offices in India. The Top 3 contestants in this round will be declared as winners of the contest. Also, the winners will receive a total cash prize of USD 20, 000.
Ends On:February 17, 2021, 12:30 UTC
The TCS Codevita selection process is a multi-round competition that is designed to identify and recognize the top-performing coders. The competition is open to students in their 2nd year and above, and it is held annually.
The competition begins with a 24-hour online coding challenge, where contestants are required to solve a set of programming problems within the given time frame. The problems are designed to test the contestants' coding skills, logical thinking, and problem-solving abilities.
Based on their performance in the first round, a select group of contestants will be chosen to proceed to the next round. This round is typically an online test that further evaluates the contestants' coding skills and knowledge of programming languages.
After clearing the online test, the selected contestants will then proceed to the interview round.
Technical Round: It the first round of the interview process, where the candidates' technical skills and knowledge of programming languages are evaluated. The interviewer will ask questions related to the candidate's programming experience, projects, and problem-solving abilities.
Managerial Round: which is the second round of the interview process, is focused on evaluating the candidate's leadership skills, team management abilities and their understanding of the industry and business. Candidates are expected to demonstrate their ability to handle projects, work with cross-functional teams, and provide solutions to business problems.
HR Round: The final round of the interview process, where the interviewer will assess the candidate's communication skills, attitude, and overall fit with the company culture. The interviewer will also provide an overview of the company's benefits and other relevant information about the role.
Based on the overall performance in the competition, the top performers will be offered job roles such as Assistant Systems Engineer and Systems Engineer at TCS. Additionally, the top 3 coders will win a total prize money of 20,000 USD, and there will be 3000+ job offers for the top performers in TCS Codevita.
Overall, the TCS Codevita selection process is an excellent opportunity for aspiring programmers to showcase their skills and compete against the best coders from around the world, while also earning recognition and pursuing career opportunities with TCS.
Note: The selection process may vary depending on the role and location. The company reserves the right to add or remove stages as per the requirement.
#Question 1
A solid cube of 10 cm x 10cm x 10 cm rests on the ground. It has a beetle on it, and some sweet honey spots at various locations on the surface of the cube. The beetle starts at a point on the surface of the cube, and goes to the honey spots in order along the surface of the cube.
#Problem Description
A solid cube of 10 cm x 10cm x 10 cm rests on the ground. It has a beetle on it, and some sweet honey spots at various locations on the surface of the cube. The beetle starts at a point on the surface of the cube, and goes to the honey spots in order along the surface of the cube.
1. If it goes from a point to another point on the same face (say X to Y), it goes in an arc of a circle that subtends an angle of 60 degrees at the centre of the circle
2.If it goes from one point to another on a different face, it goes by the shortest path on the surface of the cube, except that it never travels along the bottom of the cube
The beetle is a student of Cartesian geometry, and knows the coordinates (x, y, z) of all the points it needs to go to. The origin of coordinates it uses is one corner of the cube on the ground, and the z axis points up. Hence, the bottom surface (on which it does not crawl) is z=0, and the top surface is z=10. The beetle keeps track of all the distances travelled, and rounds the distance travelled to two decimal places once it reaches the next spot, so that the final distance is a sum of the rounded distances from spot to spot.
#Input
```sh
The first line gives an integer N, the total number of points (including the starting point) the beetle visits
The second line is a set of 3N comma separated non-negative numbers, with up to two decimal places each. These are to be interpreted in groups of three as the x, y, z coordinates of the points the beetle needs to visit in the given order.
```
#Output
```sh
One line with a number giving the total distance travelled by the beetle accurate to two decimal places. Even if the distance travelled is an integer, the output should have two decimal places.
```
#Constraints
```sh
None of the points the beetle visits is on the bottom face (z=0) or on any of the edges of the cube (the lines where two faces meet)
2<=N<=10
```
#Question 1
Write a program to find the factorial of a given number
#Solution 1
```sh
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)
print(factorial(5))
```
#Question 2
Write a program to find the Fibonacci series of a given number.
#Solution 2
```sh
def fibonacci(n):
if n <= 0:
return 0
elif n == 1:
return 1
else:
return fibonacci(n-1) + fibonacci(n-2)
print(fibonacci(6))
```
#Question 2
The parcel section of the Head Post Office is in a mess. The parcels that need to be loaded to the vans have been lined up in a row in an arbitrary order of weights. The Head Post Master wants them to be sorted in the increasing order of the weights of the parcels, with one exception. He wants the heaviest (and presumably the most valuable) parcel kept nearest his office.
#Problem Description
The parcel section of the Head Post Office is in a mess. The parcels that need to be loaded to the vans have been lined up in a row in an arbitrary order of weights. The Head Post Master wants them to be sorted in the increasing order of the weights of the parcels, with one exception. He wants the heaviest (and presumably the most valuable) parcel kept nearest his office.
You and your friend try to sort these boxes and you decide to sort them by interchanging two boxes at a time. Such an interchange needs effort equals to the product of the weights of the two boxes.
The objective is to reposition the boxes as required with minimum effort.
#Input
```sh
The first line consists of two space separated positive integers giving the number of boxes (N) and the position of the Head Post Masters office (k) where the heaviest box must be.
The second line consists of N space separated positive integers giving the weights of the boxes. You may assume that no two weights are equal.
```
#Output
```sh
The output is one line giving the total effort taken to get the boxes in sorted order, and the heaviest in position k.
```
#Constraints
```sh
N<=50
Weights <= 1000
```
#Question 3
In the theory of numbers, square free numbers have a special place. A square free number is one that is not divisible by a perfect square (other than 1).
#Problem Description
In the theory of numbers, square free numbers have a special place. A square free number is one that is not divisible by a perfect square (other than 1). Thus 72 is divisible by 36 (a perfect square), and is not a square free number, but 70 has factors 1, 2, 5, 7, 10, 14, 35 and 70. As none of these are perfect squares (other than 1), 70 is a square free number.
For some algorithms, it is important to find out the square free numbers that divide a number. Note that 1 is not considered a square free number.
In this problem, you are asked to write a program to find the number of square free numbers that divide a given number.
#Input
```sh
The only line of the input is a single integer N which is divisible by no prime number larger than 19
```
#Output
```sh
One line containing an integer that gives the number of square free numbers (not including 1)
```
#Constraints
```sh
N < 10^9
```
#Question 3
Write a program to check if a given number is prime or not.
#Answer 3
```sh
def is_prime(n):
if n <= 1:
return False
for i in range(2, n):
if n % i == 0:
return False
return True
print(is_prime(7))
```
#Question 4
Write a program to reverse a given string
#Answer 4
```sh
def reverse_string(string):
return string[::-1]
print(reverse_string("Hello World"))
```
#Question 5
Write a program to find the largest and second largest element in an array.
#Solution 5
```sh
def find_largest_elements(arr):
largest = max(arr[0], arr[1])
second_largest = min(arr[0], arr[1])
for i in range(2, len(arr)):
if arr[i] > largest:
second_largest = largest
largest = arr[i]
elif arr[i] > second_largest:
second_largest = arr[i]
return largest, second_largest
print(find_largest_elements([3, 5, 2, 7, 4, 8, 1]))
```
#Question 1
A solid cube of 10 cm x 10cm x 10 cm rests on the ground. It has a beetle on it, and some sweet honey spots at various locations on the surface of the cube. The beetle starts at a point on the surface of the cube, and goes to the honey spots in order along the surface of the cube.
#Problem Description
A solid cube of 10 cm x 10cm x 10 cm rests on the ground. It has a beetle on it, and some sweet honey spots at various locations on the surface of the cube. The beetle starts at a point on the surface of the cube, and goes to the honey spots in order along the surface of the cube.
1. If it goes from a point to another point on the same face (say X to Y), it goes in an arc of a circle that subtends an angle of 60 degrees at the centre of the circle
2.If it goes from one point to another on a different face, it goes by the shortest path on the surface of the cube, except that it never travels along the bottom of the cube
The beetle is a student of Cartesian geometry, and knows the coordinates (x, y, z) of all the points it needs to go to. The origin of coordinates it uses is one corner of the cube on the ground, and the z axis points up. Hence, the bottom surface (on which it does not crawl) is z=0, and the top surface is z=10. The beetle keeps track of all the distances travelled, and rounds the distance travelled to two decimal places once it reaches the next spot, so that the final distance is a sum of the rounded distances from spot to spot.
#Input
```sh
The first line gives an integer N, the total number of points (including the starting point) the beetle visits
The second line is a set of 3N comma separated non-negative numbers, with up to two decimal places each. These are to be interpreted in groups of three as the x, y, z coordinates of the points the beetle needs to visit in the given order.
```
#Output
```sh
One line with a number giving the total distance travelled by the beetle accurate to two decimal places. Even if the distance travelled is an integer, the output should have two decimal places.
```
#Constraints
```sh
None of the points the beetle visits is on the bottom face (z=0) or on any of the edges of the cube (the lines where two faces meet)
2<=N<=10
```
#Question 1
Write a program to find the factorial of a given number
#Solution 1
```sh
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)
print(factorial(5))
```
#Question 2
Write a program to find the Fibonacci series of a given number.
#Solution 2
```sh
def fibonacci(n):
if n <= 0:
return 0
elif n == 1:
return 1
else:
return fibonacci(n-1) + fibonacci(n-2)
print(fibonacci(6))
```
#Question 2
The parcel section of the Head Post Office is in a mess. The parcels that need to be loaded to the vans have been lined up in a row in an arbitrary order of weights. The Head Post Master wants them to be sorted in the increasing order of the weights of the parcels, with one exception. He wants the heaviest (and presumably the most valuable) parcel kept nearest his office.
#Problem Description
The parcel section of the Head Post Office is in a mess. The parcels that need to be loaded to the vans have been lined up in a row in an arbitrary order of weights. The Head Post Master wants them to be sorted in the increasing order of the weights of the parcels, with one exception. He wants the heaviest (and presumably the most valuable) parcel kept nearest his office.
You and your friend try to sort these boxes and you decide to sort them by interchanging two boxes at a time. Such an interchange needs effort equals to the product of the weights of the two boxes.
The objective is to reposition the boxes as required with minimum effort.
#Input
```sh
The first line consists of two space separated positive integers giving the number of boxes (N) and the position of the Head Post Masters office (k) where the heaviest box must be.
The second line consists of N space separated positive integers giving the weights of the boxes. You may assume that no two weights are equal.
```
#Output
```sh
The output is one line giving the total effort taken to get the boxes in sorted order, and the heaviest in position k.
```
#Constraints
```sh
N<=50
Weights <= 1000
```
#Question 3
In the theory of numbers, square free numbers have a special place. A square free number is one that is not divisible by a perfect square (other than 1).
#Problem Description
In the theory of numbers, square free numbers have a special place. A square free number is one that is not divisible by a perfect square (other than 1). Thus 72 is divisible by 36 (a perfect square), and is not a square free number, but 70 has factors 1, 2, 5, 7, 10, 14, 35 and 70. As none of these are perfect squares (other than 1), 70 is a square free number.
For some algorithms, it is important to find out the square free numbers that divide a number. Note that 1 is not considered a square free number.
In this problem, you are asked to write a program to find the number of square free numbers that divide a given number.
#Input
```sh
The only line of the input is a single integer N which is divisible by no prime number larger than 19
```
#Output
```sh
One line containing an integer that gives the number of square free numbers (not including 1)
```
#Constraints
```sh
N < 10^9
```
#Question 3
Write a program to check if a given number is prime or not.
#Answer 3
```sh
def is_prime(n):
if n <= 1:
return False
for i in range(2, n):
if n % i == 0:
return False
return True
print(is_prime(7))
```
#Question 4
Write a program to reverse a given string
#Answer 4
```sh
def reverse_string(string):
return string[::-1]
print(reverse_string("Hello World"))
```
#Question 5
Write a program to find the largest and second largest element in an array.
#Solution 5
```sh
def find_largest_elements(arr):
largest = max(arr[0], arr[1])
second_largest = min(arr[0], arr[1])
for i in range(2, len(arr)):
if arr[i] > largest:
second_largest = largest
largest = arr[i]
elif arr[i] > second_largest:
second_largest = arr[i]
return largest, second_largest
print(find_largest_elements([3, 5, 2, 7, 4, 8, 1]))
```
Being a mechanical student and getting into an IT company is very tough. One of the main reason I could able to crack TCS CodeVita is because of Edyst.
Aneeq sir, your doubt clearing sessions, daily assignments & incredible mentors support really brushed up my skills.
“My software journey started because of Edyst. Edyst preparation and referrals helped me get my first internship and job. Thank you Edyst!”
Daily coding challenge and the doubt session helped me in staying consistent. Also, the leadership board kept me motivated. Edyst gave me the best guiding materials for all the cohorts I joined. I like everything done by Edyst for my success.
I really like the Company specific practice questions they turn out to be super helpfulduring my interview, I didn't face any difficulty, the variety and range of practice questions (especially on arrays) got me my dream job. Also, the online live session were very interactive and helped me in revision and solving doubts. Thank you Edyst.
I practice a lot at Edyst platform and what I learnt is how to code, self-learning and more & more about the practical knowledge which gradually increased my confidence level. Edyst was great platform which changed my career.
I feel the best thing about edyst is its company-specific guidance and the huge problem sets covering up almost all the concepts from beginner to advanced concepts, it helped me a lot for my placement preparation
#Question 1
A solid cube of 10 cm x 10cm x 10 cm rests on the ground. It has a beetle on it, and some sweet honey spots at various locations on the surface of the cube. The beetle starts at a point on the surface of the cube, and goes to the honey spots in order along the surface of the cube.
#Problem Description
A solid cube of 10 cm x 10cm x 10 cm rests on the ground. It has a beetle on it, and some sweet honey spots at various locations on the surface of the cube. The beetle starts at a point on the surface of the cube, and goes to the honey spots in order along the surface of the cube.
1. If it goes from a point to another point on the same face (say X to Y), it goes in an arc of a circle that subtends an angle of 60 degrees at the centre of the circle
2.If it goes from one point to another on a different face, it goes by the shortest path on the surface of the cube, except that it never travels along the bottom of the cube
The beetle is a student of Cartesian geometry, and knows the coordinates (x, y, z) of all the points it needs to go to. The origin of coordinates it uses is one corner of the cube on the ground, and the z axis points up. Hence, the bottom surface (on which it does not crawl) is z=0, and the top surface is z=10. The beetle keeps track of all the distances travelled, and rounds the distance travelled to two decimal places once it reaches the next spot, so that the final distance is a sum of the rounded distances from spot to spot.
#Input
```sh
The first line gives an integer N, the total number of points (including the starting point) the beetle visits
The second line is a set of 3N comma separated non-negative numbers, with up to two decimal places each. These are to be interpreted in groups of three as the x, y, z coordinates of the points the beetle needs to visit in the given order.
```
#Output
```sh
One line with a number giving the total distance travelled by the beetle accurate to two decimal places. Even if the distance travelled is an integer, the output should have two decimal places.
```
#Constraints
```sh
None of the points the beetle visits is on the bottom face (z=0) or on any of the edges of the cube (the lines where two faces meet)
2<=N<=10
```
#Question 1
Write a program to find the factorial of a given number
#Solution 1
```sh
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)
print(factorial(5))
```
#Question 2
Write a program to find the Fibonacci series of a given number.
#Solution 2
```sh
def fibonacci(n):
if n <= 0:
return 0
elif n == 1:
return 1
else:
return fibonacci(n-1) + fibonacci(n-2)
print(fibonacci(6))
```
#Question 2
The parcel section of the Head Post Office is in a mess. The parcels that need to be loaded to the vans have been lined up in a row in an arbitrary order of weights. The Head Post Master wants them to be sorted in the increasing order of the weights of the parcels, with one exception. He wants the heaviest (and presumably the most valuable) parcel kept nearest his office.
#Problem Description
The parcel section of the Head Post Office is in a mess. The parcels that need to be loaded to the vans have been lined up in a row in an arbitrary order of weights. The Head Post Master wants them to be sorted in the increasing order of the weights of the parcels, with one exception. He wants the heaviest (and presumably the most valuable) parcel kept nearest his office.
You and your friend try to sort these boxes and you decide to sort them by interchanging two boxes at a time. Such an interchange needs effort equals to the product of the weights of the two boxes.
The objective is to reposition the boxes as required with minimum effort.
#Input
```sh
The first line consists of two space separated positive integers giving the number of boxes (N) and the position of the Head Post Masters office (k) where the heaviest box must be.
The second line consists of N space separated positive integers giving the weights of the boxes. You may assume that no two weights are equal.
```
#Output
```sh
The output is one line giving the total effort taken to get the boxes in sorted order, and the heaviest in position k.
```
#Constraints
```sh
N<=50
Weights <= 1000
```
#Question 3
In the theory of numbers, square free numbers have a special place. A square free number is one that is not divisible by a perfect square (other than 1).
#Problem Description
In the theory of numbers, square free numbers have a special place. A square free number is one that is not divisible by a perfect square (other than 1). Thus 72 is divisible by 36 (a perfect square), and is not a square free number, but 70 has factors 1, 2, 5, 7, 10, 14, 35 and 70. As none of these are perfect squares (other than 1), 70 is a square free number.
For some algorithms, it is important to find out the square free numbers that divide a number. Note that 1 is not considered a square free number.
In this problem, you are asked to write a program to find the number of square free numbers that divide a given number.
#Input
```sh
The only line of the input is a single integer N which is divisible by no prime number larger than 19
```
#Output
```sh
One line containing an integer that gives the number of square free numbers (not including 1)
```
#Constraints
```sh
N < 10^9
```
#Question 3
Write a program to check if a given number is prime or not.
#Answer 3
```sh
def is_prime(n):
if n <= 1:
return False
for i in range(2, n):
if n % i == 0:
return False
return True
print(is_prime(7))
```
#Question 4
Write a program to reverse a given string
#Answer 4
```sh
def reverse_string(string):
return string[::-1]
print(reverse_string("Hello World"))
```
#Question 5
Write a program to find the largest and second largest element in an array.
#Solution 5
```sh
def find_largest_elements(arr):
largest = max(arr[0], arr[1])
second_largest = min(arr[0], arr[1])
for i in range(2, len(arr)):
if arr[i] > largest:
second_largest = largest
largest = arr[i]
elif arr[i] > second_largest:
second_largest = arr[i]
return largest, second_largest
print(find_largest_elements([3, 5, 2, 7, 4, 8, 1]))
```
All TCS CodeVita Questions
All TCS CodeVita Questions