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.
There are several benefits for Computer Science Engineering (CSE) students to participate in Amazon's 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.
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.
The Amazon recruitment exam for Computer Science Engineering (CSE) students in India typically follows the pattern as described:
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.
The Amazon recruitment process for Computer Science Engineering (CSE) students in India typically includes the following selection stages:
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.
#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
```
Edyst's training style completely resonated with me. I approached programming as more than a subject. Thanks to Edyst team for the guidance!
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!
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.
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.
#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
```
All Amazon Questions
All Amazon Questions