.png){kind=logo}
.svg)
Amazon
About Amazon
Amazon.com, Inc. is a leading American multinational corporation headquartered in Seattle, Washington. It conducts a comprehensive recruitment process for hiring Computer Science Engineering (CSE) students in India. The process typically includes an online assessment test, followed by multiple rounds of technical and behavioral interviews.
It is one of the largest online retailers in the world, it has established itself as a household name and a valuable brand. The company began as an online bookstore, but quickly expanded its offerings to include a wide range of products such as DVDs, CDs, software, video games, electronics, apparel, furniture, food, toys, and jewelry. In addition to these offerings, Amazon has also made a name for itself in the consumer electronics market with its popular Kindle e-book reader and Kindle Fire tablet computer. As a major provider of cloud computing services, Amazon is considered to be one of the Big Five technology companies in the United States. With its vast array of products and services, Amazon continues to be a driving force in the e-commerce industry.
If you're looking to sit for the Amazon placement exam, you've come to the right place. Amazon is known for its rigorous recruitment process, especially when it comes to hiring Computer Science Engineering (CSE) students in India. The placement exam is the first step in this process and can be a daunting task if you're not prepared.
To help you prepare, we've compiled a list of best practices and advice to help you succeed in the Amazon placement exam. We'll cover everything from the exam pattern and syllabus to interview questions and registration processes. You'll also find practice questions and tips on how to crack the exam.
It's important to note that cheating is never the right option. Amazon has a strict policy against cheating and any attempt to cheat during the placement exam could result in severe consequences, including being banned from the recruitment process altogether. So, it's important to approach the exam with honesty and integrity, and to rely on your preparation and knowledge to succeed.
Benefits of Amazon Recruitment Exam
There are several benefits for Computer Science Engineering (CSE) students to participate in Amazon's recruitment exam:
- Opportunities to work with top industry professionals: Amazon is one of the world's largest and most successful technology companies, participating and selection in its recruitment process provides CSE students with an opportunity to work with some of the best professionals in the industry.
- Exposure to cutting-edge technology: Amazon is known for its innovative use of technology, and by getting selected in the recruitment process, CSE students will gain exposure to the latest trends and technologies in the field.
- Hands-on experience with product development: Amazon focused on developing and launching new products and services, and CSE students will have the opportunity to work on real-world projects that have an immediate impact. They will also have the opportunity to learn about the entire product development lifecycle, from design and development to testing and deployment.
- Opportunities to work on cutting-edge technology: Amazon is often at the forefront of new technology, and selected CSE students will have the opportunity to work with the latest tools and technologies in the field.
- Chance to be part of a team: Amazon often has a collaborative environment, and selected CSE students will have the opportunity to work with a team of engineers, designers, and product managers to bring new products to market.
- Focus on solving real-world problems: Amazon focused on solving problems for their customers, and selected CSE students will have the opportunity to apply their technical skills to make a real difference in people's lives.
- Chance to see the impact of your work: Amazon allows selected CSE students to see the direct impact of their work. They can see how their contributions are helping to improve the lives of customers, and that can be a great source of motivation and satisfaction.
- Potential for high-growth career: Product companies like Amazon are known for their rapid growth, and selected CSE students will have the opportunity to grow and advance their careers quickly. Many successful technology leaders have come from product companies.
Eligibility criteria for Amazon Recruitment Exam
The eligibility criteria for Amazon's recruitment exam for Computer Science Engineering (CSE) students in India typically includes the following:
Educational qualifications: Candidates should have a Bachelor's or Master's degree in Computer Science, Computer Engineering, or a related field.
Education Gap: There is no specific percentage criteria for class 10th, 12th or graduation. However, candidates should have an education gap of not more than one year.
Technical Skills: Candidates should have a strong understanding of computer science fundamentals, including data structures, algorithms, and programming languages such as C++ and Java. They should also have experience with software development, debugging, and problem-solving.
Communication Skills: Candidates should have excellent verbal and written communication skills, as well as the ability to work in a collaborative team environment.
Other Requirements: Candidates should be willing to work in a fast-paced and dynamic environment and should be able to adapt to new technologies quickly. They should also be able to meet the physical demands of the job, including prolonged periods of sitting, typing, and staring at a computer screen.
Please note that this is a general idea, the eligibility criteria and requirements may vary depending on the location and role you are applying for.
Syllabus for Amazon Recruitment Exam
The syllabus for Amazon's recruitment exam for Computer Science Engineering (CSE) students in India typically includes the following areas:
Aptitude: This section includes topics such as Pipes and Cisterns, Volumes, Profit and Loss, Compound Interest, Indices and Surds, Quadratic Equations, Ratio and Proportion, Time and Distance, Problems on Trains, Areas, Averages, Time and Work, Simple Interest, Boats and Streams, Problems on L.C.M and H.C.F, Permutations and Combinations, Probability, Mixtures and Allegations, Percentages, Logical Reasoning, Classification, Verbal Reasoning, Mirror Images, Completion of Incomplete Pattern, Logical Problems, Number Series, Clock Puzzles, Logical Games, Analogies, Matching Definitions, Verbal Classification, Data Sufficiency, Missing Letters, Water Images, Calendars, and Data Interpretation.
Technical & Programming: This section includes topics such as HTML, CSS, C, C++, DBMS, Java, Data Structures, MySQL, Cloud Computing, Computer Networks, Operating Systems, IOT, Javascript, PHP, Perl, and Python.
The exam is intended to test the candidates' knowledge of programming, data structures, algorithms, and computer science fundamentals. Candidates should have a solid foundation in these areas and be able to demonstrate their ability to solve complex problems.
Amazon Recruitment Exam Pattern
The Amazon recruitment exam for Computer Science Engineering (CSE) students in India typically follows the pattern as described:
- The written round is divided into three sections: Aptitude, Technical, and Coding.
- Aptitude section has 5 questions, Technical section has 15 questions, and Coding section has 2 questions, for a total of 22 questions.
- The total time allotted for the written round is 60 minutes, and the test carries a total of 40 marks.
- The Technical and Aptitude sections include multiple-choice questions, carrying one mark each. In the coding section, each question carries 10 marks.
- There is negative marking for MCQs only.
- The Technical section consists of questions from C language, DBMS, data structure, operating systems, networking, etc.
- The Aptitude section has questions from common reasoning, verbal, and mathematical topics like averages, time & work, number system, arrangements, series, syllogism, analogies, sentence completion, error detection, antonyms/synonyms, etc.
- The Coding section includes questions based on arrays, stacks, and other algorithmic and mathematical concepts.
Overall, the level of the paper is moderate. Only those candidates who clear the written exam will qualify for the next round, which is usually a technical interview round.
Amazon Selection Process:
The Amazon recruitment process for Computer Science Engineering (CSE) students in India typically includes the following selection stages:
- Written Test: This is the first stage of the selection process and it is used to evaluate the candidates' technical skills and aptitude for the role of a software development engineer. The test includes multiple-choice questions that assess the candidates' knowledge of data structures, algorithms, and programming languages such as C++ and Java.
- Interview Round: Candidates who clear the written test are invited for the interview round. This round is designed to evaluate the candidates' technical skills and problem-solving abilities through a series of coding exercises and discussions. The interview is usually conducted by experienced software development engineers from Amazon.
- Technical Interview: In this round, the shortlisted candidates will be interviewed by the experienced software development engineers from Amazon. The interview will be based on the technical skills and knowledge of the candidate on the subject matter.
- Behavioral Interview: The behavioral interview is usually conducted by a hiring manager or a senior leader from Amazon. This round is designed to evaluate the candidates' communication skills, teamwork, and leadership abilities.
- On-site Interview: The final round of the recruitment process is the on-site interview, where the selected candidates are invited to Amazon's office for a full day of interviews. The on-site interview round includes a mix of technical and behavioral interviews, and is usually conducted by a panel of Amazon employees.
The Amazon selection process is rigorous and designed to identify the best talent in the field. Candidates are expected to have a strong understanding of computer science fundamentals, a solid foundation in data structures and algorithms, and the ability to work in a fast-paced and dynamic environment.
Popular Questions
#Question 1
K largest elements from a big file or array.
#Solution 1
Read the file or array and store it in a list.
Sort the list in descending order.
Slice the first k elements from the sorted list.
Here's an example implementation in Python
```sh
import heapq
def k_largest_elements(arr: List[int], k: int) -> List[int]:
return heapq.nlargest(k, arr)
```
#Question 1
Given a string, write a function to check if it is a palindrome.
#Question 2
Find a triplet a, b, c such that a2 = b2 + c2. Variations of this problem like finding a triplet with sum equal to 0. Find a pair with a given sum. All such questions are efficiently solved using hashing.
#Solution 2
```sh
def find_triplet(arr: List[int]) -> Tuple[int, int, int]:
n = len(arr)
squares = {}
for i in range(n):
squares[arr[i]*arr[i]] = arr[i]
for i in range(n):
for j in range(i+1,n):
if (arr[i]*arr[i] - arr[j]*arr[j]) in squares:
return (squares[arr[i]*arr[i] - arr[j]*arr[j]], arr[i], arr[j])
return None
```
#Question 2
Given an array of integers, write a function to find the second largest element in the array.
#Question 3
Binary tree traversal questions like left view,.
#Answer 3
Left View: To print the left view of a binary tree, we need to traverse the tree in a level order fashion, keeping track of the maximum level seen so far. When we encounter a node at a new level, we print its value.
```sh
def left_view(root: Node) -> List[int]:
max_level = -1
result = []
queue = [(root, 0)]
while queue:
node, level = queue.pop(0)
if level > max_level:
result.append(node.val)
max_level = level
if node.left:
queue.append((node.left, level+1))
if node.right:
queue.append((node.right, level+1))
return result
```
#Question 3
Given a binary tree, write a function to check if it is a binary search tree.
#Question 4
Rotate a matrix by 90 degrees.
#Answer 4
There are multiple ways to rotate a matrix by 90 degrees, here is one approach using the following steps:
Transpose the matrix by swapping the rows and columns.
Reverse each row of the transposed matrix.
Here's an example implementation in Python:
``` sh
def rotate_matrix(matrix: List[List[int]]) -> List[List[int]]:
# Transpose the matrix
for i in range(len(matrix)):
for j in range(i, len(matrix)):
matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
# Reverse each row of the transposed matrix
for row in matrix:
row.reverse()
return matrix
```
#Question 5
Find the number of consecutive days before a given day on which the price of a stock was less than or equal to the price of the given day.
#Solution 5
The stock span problem is a financial problem that asks to find the number of consecutive days before a given day on which the price of a stock was less than or equal to the price of the given day.
One approach to solving the stock span problem is to use a stack to keep track of the prices and their indices. We start by pushing the first price and its index onto the stack, and for each subsequent price, we pop elements from the stack while the stack is not empty and the price at the top of the stack is less than or equal to the current price. The number of days before the current day is equal to the difference between the current index and the index of the price at the top of the stack.
Here's an example implementation in Python:
```sh
def stock_span(prices: List[int]) -> List[int]:
n = len(prices)
span = [1] * n
stack = []
stack.append(0)
for i in range(1, n):
while stack and prices[stack[-1]] <= prices[i]:
stack.pop()
if stack:
span[i] = i - stack[-1]
stack.append(i)
return span
```
Previously Asked Question
#Question 1
K largest elements from a big file or array.
#Solution 1
Read the file or array and store it in a list.
Sort the list in descending order.
Slice the first k elements from the sorted list.
Here's an example implementation in Python
```sh
import heapq
def k_largest_elements(arr: List[int], k: int) -> List[int]:
return heapq.nlargest(k, arr)
```
#Question 1
Given a string, write a function to check if it is a palindrome.
#Question 2
Find a triplet a, b, c such that a2 = b2 + c2. Variations of this problem like finding a triplet with sum equal to 0. Find a pair with a given sum. All such questions are efficiently solved using hashing.
#Solution 2
```sh
def find_triplet(arr: List[int]) -> Tuple[int, int, int]:
n = len(arr)
squares = {}
for i in range(n):
squares[arr[i]*arr[i]] = arr[i]
for i in range(n):
for j in range(i+1,n):
if (arr[i]*arr[i] - arr[j]*arr[j]) in squares:
return (squares[arr[i]*arr[i] - arr[j]*arr[j]], arr[i], arr[j])
return None
```
#Question 2
Given an array of integers, write a function to find the second largest element in the array.
#Question 3
Binary tree traversal questions like left view,.
#Answer 3
Left View: To print the left view of a binary tree, we need to traverse the tree in a level order fashion, keeping track of the maximum level seen so far. When we encounter a node at a new level, we print its value.
```sh
def left_view(root: Node) -> List[int]:
max_level = -1
result = []
queue = [(root, 0)]
while queue:
node, level = queue.pop(0)
if level > max_level:
result.append(node.val)
max_level = level
if node.left:
queue.append((node.left, level+1))
if node.right:
queue.append((node.right, level+1))
return result
```
#Question 3
Given a binary tree, write a function to check if it is a binary search tree.
#Question 4
Rotate a matrix by 90 degrees.
#Answer 4
There are multiple ways to rotate a matrix by 90 degrees, here is one approach using the following steps:
Transpose the matrix by swapping the rows and columns.
Reverse each row of the transposed matrix.
Here's an example implementation in Python:
``` sh
def rotate_matrix(matrix: List[List[int]]) -> List[List[int]]:
# Transpose the matrix
for i in range(len(matrix)):
for j in range(i, len(matrix)):
matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
# Reverse each row of the transposed matrix
for row in matrix:
row.reverse()
return matrix
```
#Question 5
Find the number of consecutive days before a given day on which the price of a stock was less than or equal to the price of the given day.
#Solution 5
The stock span problem is a financial problem that asks to find the number of consecutive days before a given day on which the price of a stock was less than or equal to the price of the given day.
One approach to solving the stock span problem is to use a stack to keep track of the prices and their indices. We start by pushing the first price and its index onto the stack, and for each subsequent price, we pop elements from the stack while the stack is not empty and the price at the top of the stack is less than or equal to the current price. The number of days before the current day is equal to the difference between the current index and the index of the price at the top of the stack.
Here's an example implementation in Python:
```sh
def stock_span(prices: List[int]) -> List[int]:
n = len(prices)
span = [1] * n
stack = []
stack.append(0)
for i in range(1, n):
while stack and prices[stack[-1]] <= prices[i]:
stack.pop()
if stack:
span[i] = i - stack[-1]
stack.append(i)
return span
```
Testimonials
Ria
Vaishnavi
Edyst's training style completely resonated with me. I approached programming as more than a subject. Thanks to Edyst team for the guidance!
Pruthviraj
Sakila
I started practising on Edyst platform since my 3rd year of college focused on placements & always liked the way they helped us when we were stuck at a particular problem.
Thank you, Edyst for all the assistance and amazing support!
Dileep
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.
Sriram
When I joined the Edyst courses I received personalized mentoring on how to crack coding rounds of different companies. Through a combination of coding skills and great projects, I received multiple offers above 6+ lakhs per annum. Finally I joined for 8+ Lakhs package. Thanks for all the support, from Edyst Team.
Coding Interview Round Sample Questions
#Question 1
K largest elements from a big file or array.
#Solution 1
Read the file or array and store it in a list.
Sort the list in descending order.
Slice the first k elements from the sorted list.
Here's an example implementation in Python
```sh
import heapq
def k_largest_elements(arr: List[int], k: int) -> List[int]:
return heapq.nlargest(k, arr)
```
#Question 1
Given a string, write a function to check if it is a palindrome.
#Question 2
Find a triplet a, b, c such that a2 = b2 + c2. Variations of this problem like finding a triplet with sum equal to 0. Find a pair with a given sum. All such questions are efficiently solved using hashing.
#Solution 2
```sh
def find_triplet(arr: List[int]) -> Tuple[int, int, int]:
n = len(arr)
squares = {}
for i in range(n):
squares[arr[i]*arr[i]] = arr[i]
for i in range(n):
for j in range(i+1,n):
if (arr[i]*arr[i] - arr[j]*arr[j]) in squares:
return (squares[arr[i]*arr[i] - arr[j]*arr[j]], arr[i], arr[j])
return None
```
#Question 2
Given an array of integers, write a function to find the second largest element in the array.
#Question 3
Binary tree traversal questions like left view,.
#Answer 3
Left View: To print the left view of a binary tree, we need to traverse the tree in a level order fashion, keeping track of the maximum level seen so far. When we encounter a node at a new level, we print its value.
```sh
def left_view(root: Node) -> List[int]:
max_level = -1
result = []
queue = [(root, 0)]
while queue:
node, level = queue.pop(0)
if level > max_level:
result.append(node.val)
max_level = level
if node.left:
queue.append((node.left, level+1))
if node.right:
queue.append((node.right, level+1))
return result
```
#Question 3
Given a binary tree, write a function to check if it is a binary search tree.
#Question 4
Rotate a matrix by 90 degrees.
#Answer 4
There are multiple ways to rotate a matrix by 90 degrees, here is one approach using the following steps:
Transpose the matrix by swapping the rows and columns.
Reverse each row of the transposed matrix.
Here's an example implementation in Python:
``` sh
def rotate_matrix(matrix: List[List[int]]) -> List[List[int]]:
# Transpose the matrix
for i in range(len(matrix)):
for j in range(i, len(matrix)):
matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
# Reverse each row of the transposed matrix
for row in matrix:
row.reverse()
return matrix
```
#Question 5
Find the number of consecutive days before a given day on which the price of a stock was less than or equal to the price of the given day.
#Solution 5
The stock span problem is a financial problem that asks to find the number of consecutive days before a given day on which the price of a stock was less than or equal to the price of the given day.
One approach to solving the stock span problem is to use a stack to keep track of the prices and their indices. We start by pushing the first price and its index onto the stack, and for each subsequent price, we pop elements from the stack while the stack is not empty and the price at the top of the stack is less than or equal to the current price. The number of days before the current day is equal to the difference between the current index and the index of the price at the top of the stack.
Here's an example implementation in Python:
```sh
def stock_span(prices: List[int]) -> List[int]:
n = len(prices)
span = [1] * n
stack = []
stack.append(0)
for i in range(1, n):
while stack and prices[stack[-1]] <= prices[i]:
stack.pop()
if stack:
span[i] = i - stack[-1]
stack.append(i)
return span
```
Technical Interview Round Sample Questions
.svg){kind=icon}
HR Interview Round Sample Questions
Amazon
All Amazon Questions
Services Company Mega Pack
Services Company Mega PackProduct Companies Mega Pack
All Amazon Questions