Amazon Software Developer Intern Interview Questions & Experience Guide

Interview Preparation
,
81

Company Name: Amazon

Position: Software Developer Intern

Location: Hyderabad

Application Process: I applied for the job as an SDE - Intern through campus placements at The LNM Institute of Information Technology. The eligibility criteria included having a CGPA above 7.

Interview Rounds:

  • Round 1 - Video Call (Technical):
    • Questions Asked:
      1. Count triplets in a sorted doubly linked list whose sum is equal to a given value x:
        • Given a sorted doubly linked list of distinct nodes and an integer ‘X’, the task was to count the number of triplets in the list that sum up to ‘X’.
      2. Number of Islands:
        • Given a non-empty grid of 0s and 1s, the task was to find the number of islands, where an island is a group of adjacent 1s (horizontally or vertically).
      3. Flip Bits:
        • Given an array of integers consisting of zeros and ones, the task was to select a subset and flip the bits of that subset to maximize the number of 1s in the array.
    • Your Approach:
      • For the first question, I explained the brute-force approach initially and then optimized it using a two-pointer technique.
      • For the second question, I used Depth-First Search (DFS) to traverse the grid and count the islands.
      • For the third question, I discussed the Kadane’s algorithm approach to solve the problem efficiently.
    • Outcome: I was able to explain my approaches clearly and code the solutions within the given time. The interviewer seemed satisfied with my answers.

Preparation Tips:

  • Topics to Prepare: Data Structures, Algorithms, Operating System, OOPS, DBMS.
  • Time Required: 3 months.
  • Tips:
    1. Practice topic-wise questions from Leetcode. After solving each question, review the top Discuss posts to improve.
    2. Go through past year’s interview experiences to understand the kind of questions asked by Amazon.
    3. Focus on covering all Computer Science fundamentals at a basic level before diving deep into any topic.
    4. Ensure your resume is honest and be prepared to answer questions on anything mentioned in it.

Conclusion:

The interview was a great learning experience. I felt well-prepared due to my consistent practice and thorough understanding of DSA and CS fundamentals. The key to success was explaining my thought process clearly and optimizing my solutions. For future candidates, I would recommend focusing on problem-solving skills and practicing mock interviews to build confidence.

Final Outcome: Selected!

82

Company Name: Amazon

Position: Software Developer Intern

Application Process: I was interviewed in December 2020. The process consisted of 2 rounds: a coding test and a video call interview.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Check If Linked List Is Palindrome: Given a singly linked list, determine if it is a palindrome.
      2. Pair Sum: Given an integer array and a target sum, return all pairs of elements that sum up to the target.
    • Your Approach: For the palindrome question, I used the two-pointer technique to compare the first half of the list with the reversed second half. For the pair sum problem, I used a hash set to efficiently find pairs.
    • Outcome: Passed this round.

  • Round 2 - Video Call Interview:

    • Questions Asked:
      1. Square Root (Decimal): Implement a function to find the square root of a number with precision up to a given number of decimal places.
      2. SQL Question: Retrieve the top 5 cars with the maximum speed from a given database.
    • Your Approach: For the square root problem, I used the binary search approach to narrow down the solution. For the SQL question, I wrote a query using the ORDER BY and LIMIT clauses.
    • Outcome: Successfully answered both questions and advanced to the next stage.

Preparation Tips:

  • Focus on Data Structures, especially trees and graphs, and practice coding questions daily.
  • Analyze the time and space complexity of your solutions and work on optimizing them.
  • Strengthen your understanding of Operating Systems, Databases, and Object-Oriented Programming.
  • Refer to platforms like LeetCode and GeeksforGeeks for practice and concepts.

Conclusion:
The interview process was challenging but rewarding. Practicing regularly and understanding core concepts thoroughly helped me perform well. My advice to future candidates is to stay consistent with their preparation and focus on problem-solving strategies.

83

Company Name: Amazon

Position: Software Developer Intern

Application Process: I was interviewed before September 2020. The process consisted of 4 rounds: a coding test followed by three video call interviews.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Check Subset: Given two integer arrays, determine if one is a subset of the other.
      2. Kth Smallest and Largest Element of Array: Find the Kth smallest and largest elements in an array.
    • Your Approach: For the subset problem, I used a hash set to check for inclusion efficiently. For the Kth element problem, I implemented a modified quicksort approach to achieve O(n) average time complexity.
    • Outcome: Passed this round.

  • Round 2 - Video Call (Technical):

    • Questions Asked:
      1. Longest Path in a DAG: Given a Directed Acyclic Graph, find the longest path.
      2. LRU Cache Implementation: Design and implement an LRU cache.
    • Your Approach: For the DAG problem, I used topological sorting and dynamic programming. For the LRU cache, I combined a hash map and a doubly linked list for O(1) operations.
    • Outcome: The interviewer was helpful, and I passed this round.

  • Round 3 - Video Call (Technical):

    • Questions Asked:
      1. String Transformation: Transform a string by repeatedly taking the smallest character and appending it to a new string.
    • Your Approach: I used a priority queue to efficiently manage the smallest character selection.
    • Outcome: The interviewer also asked about C++ and OOP concepts, and I passed this round.

  • Round 4 - Video Call (Technical):

    • Questions Asked:
      1. Sorted Linked List to Balanced BST: Convert a sorted linked list into a balanced binary search tree.
      2. Delete Middle Element from Stack: Remove the middle element from a stack.
    • Your Approach: For the BST problem, I used a recursive approach to ensure balance. For the stack problem, I used an auxiliary stack to track the middle element.
    • Outcome: This was the final round, and I passed it successfully.

Preparation Tips:

  • Focus on Data Structures and Algorithms, especially graphs, dynamic programming, and system design.
  • Practice coding problems regularly on platforms like LeetCode and GeeksforGeeks.
  • Be thorough with C++/Java and OOP concepts, as they are often tested.
  • Understand the time and space complexities of your solutions.

Conclusion:
Overall, the interview process was challenging but rewarding. The interviewers were supportive and provided hints when needed. I would advise future candidates to:

  1. Practice consistently to improve problem-solving speed.
  2. Revise core concepts like OS, DBMS, and networking, as they might come up.
  3. Stay calm and confident during interviews, and don’t hesitate to ask for clarifications.

I was selected for the internship, and I’m excited to join Amazon!

84

Company Name: Amazon

Position: Software Developer Intern

Location: Bangalore

Application Process: I applied for the job as an SDE - Intern through the campus placement process. The eligibility criteria included having a CGPA above 6.

Interview Rounds:

  • Round 1 - Coding Test (Hackerrank):

    • Questions Asked:
      1. Merge overlapping intervals: Given ‘N’ intervals, merge all overlapping intervals and return the list of merged intervals sorted in ascending order.
      2. Josephus problem: ‘N’ people standing in a circle, eliminate every ‘K-th’ person until one remains.
    • Your Approach: For the first question, I sorted the intervals based on their start times and then iterated through them to merge overlapping ones. For the second question, I used a recursive approach to simulate the elimination process.
    • Outcome: Passed this round.

  • Round 2 - Coding Test (Google Docs):

    • Questions Asked:
      1. Largest rectangle in a histogram: Find the largest rectangular area under a histogram.
      2. Boundary traversal of a binary tree: Print the boundary nodes of a binary tree in an anti-clockwise direction.
    • Your Approach: For the histogram problem, I used a stack-based approach to calculate the maximum area. For the binary tree problem, I broke it down into left boundary, leaves, and right boundary traversal.
    • Outcome: The interviewer was helpful and provided hints when I got stuck. Passed this round.

  • Round 3 - Face to Face (Google Meet):

    • Questions Asked:
      1. Maximum sum rectangle: Find the rectangle with the maximum sum in a given matrix.
      2. Rotated array: Find the number of rotations (‘K’) in a rotated sorted array.
    • Your Approach: For the maximum sum rectangle, I used Kadane’s algorithm extended to 2D. For the rotated array, I performed a binary search to find the pivot point.
    • Outcome: The interviewer also asked detailed questions about my resume projects. Passed this round.

Preparation Tips:

  • Focus on Dynamic Programming, Greedy Techniques, Data Structures, OOPs, DBMS, and Graph Theory.
  • Practice past interview questions from platforms like LeetCode and InterviewBit.
  • Maintain a CGPA of 8+ as shortlisting sometimes depends on it.
  • Mention at least one project or past work experience in your resume.

Conclusion:
Overall, the interview process was smooth, and the interviewers were supportive. I would advise future candidates to thoroughly prepare for coding rounds and be ready to explain their resume projects in detail. Keeping a one-page resume with relevant projects is also crucial.

85

Company Name: Amazon
Position: Software Developer Intern
Location: Not specified
Application Process: Applied online in November 2021.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Container With Most Water: Given a sequence of non-negative integers representing heights, find two lines that form a container with the most water.
      2. Minimum Travel Cost: A graph problem involving states and travel costs between them.
    • Your Approach: For the first question, I used a two-pointer approach to maximize the area. For the second, I applied Dijkstra’s algorithm to find the minimum travel cost.
    • Outcome: Passed this round.

  • Round 2 - Face to Face (DSA Round):

    • Questions Asked:
      1. First Missing Positive: Find the first missing positive integer in an array.
      2. Simplify the Directory: Given a Unix-style directory path, simplify it.
    • Your Approach: For the first question, I used a hash set to track positive integers. For the second, I used a stack to handle directory navigation.
    • Outcome: Passed this round.

  • Round 3 - Face to Face (DSA Round):

    • Questions Asked:
      1. Pair Sum: Find all pairs in an array that sum to a given value.
      2. Frequency In A Sorted Array: Count occurrences of a number in a sorted array.
    • Your Approach: For the first question, I used a hash map to track pairs. For the second, I used binary search to find the frequency.
    • Outcome: Rejected after this round.

Preparation Tips:

  • Topics to Focus On: Arrays, Linked Lists, Binary Search, Stack, Queue, DFS, BFS, String, Recursion.
  • Resources: Leetcode and the SDE sheet by Striver were very helpful.
  • Time Required: 2 months of dedicated preparation.
  • Additional Tips:
    1. Solve the first question quickly to save time for the second.
    2. Ensure your resume includes projects and internships for potential questions.

Conclusion:
Overall, the interview process was challenging but fair. I could have improved by practicing more graph problems and optimizing my solutions further. For future candidates, focus on mastering DSA fundamentals and solving problems efficiently under time constraints.

86

Company Name: Amazon

Position: Software Developer Intern

Location: Hyderabad

Application Process: Applied through campus placement with eligibility criteria of above 7 CGPA.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      • Q1. Maximal AND Subsequences: Given an array of integers, find the number of k-element subsequences where the bitwise AND of the elements is maximal. Also, determine the maximal AND value.
    • Your Approach: I tackled this problem by first understanding the bitwise operations and then iterating through the array to find the maximal AND value and count the valid subsequences. I used bit manipulation techniques to optimize the solution.
    • Outcome: Cleared the round.

  • Round 2 - Coding Test:

    • Questions Asked:
      • Q1. What are semaphores?
    • Your Approach: I explained semaphores as a synchronization mechanism used in operating systems to control access to shared resources by multiple processes or threads.
    • Outcome: Cleared the round.

  • Round 3 - Coding Test:

    • Questions Asked:
      • Q1. What is virtual memory?
    • Your Approach: I described virtual memory as a memory management technique that provides an idealized abstraction of the storage resources available on a machine, allowing programs to behave as if they have contiguous working memory.
    • Outcome: Cleared the round.

Preparation Tips:

  • Topics to Prepare: Data Structures, Pointers, OOPS, System Design.
  • Time Required: 3 months.
  • Practice: Solve at least 250 coding problems.
  • Projects: Work on at least 2 projects to showcase on your resume.
  • Resume Tips: Ensure your resume includes genuine projects and avoid false information.

Conclusion:
Overall, the interview process was challenging but fair. I could have prepared more thoroughly for system design questions. My advice to future candidates is to focus on problem-solving skills and ensure a strong understanding of core CS concepts. Despite my efforts, I was rejected, but the experience was invaluable for future opportunities.

87

Company Name: Amazon

Position: Software Developer Intern

Location: Bengaluru

Application Process: I applied for the job as an SDE - Intern through the campus placement process.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Find Number of Islands: Given a 2D matrix of 1s (land) and 0s (water), count the number of islands.
      2. Search in a Row-wise and Column-wise Sorted Matrix: Given an N x N sorted matrix, search for a target value efficiently.
    • Your Approach: For the first question, I used a BFS approach to traverse connected 1s. For the second question, I optimized the search by leveraging the sorted property of the matrix.
    • Outcome: Passed this round.

  • Round 2 - Video Call (Technical):

    • Questions Asked:
      1. Merge Two Sorted Linked Lists: Merge two sorted linked lists into one sorted list.
      2. Pair Sum: Find all pairs in an array that sum up to a given value.
    • Your Approach: For the linked list question, I used a two-pointer approach. For the pair sum problem, I utilized a hash map for O(n) time complexity.
    • Outcome: Cleared this round successfully.

  • Round 3 - Video Call (Technical):

    • Questions Asked:
      1. Rat in a Maze: Given a maze, find all possible paths for a rat to reach the destination using backtracking.
    • Your Approach: I implemented a backtracking solution to explore all possible paths while marking visited cells.
    • Outcome: This was the final round, and I was selected for the internship.

Preparation Tips:

  • Topics to Focus On: Data Structures (especially Trees and Graphs), Arrays, Backtracking, Pointers, OOPS, System Design, Greedy Algorithms, and Dynamic Programming.
  • Practice: Solve as many problems as possible, preferably under time constraints.
  • Consistency: Regular practice is key to mastering problem-solving.
  • Resume Tips: Highlight at least 2 projects with brief descriptions and mention achievements like coding contest rankings.

Conclusion:
Overall, the interview process was challenging but fair. The questions were focused on problem-solving and algorithmic thinking. I could have prepared more thoroughly for backtracking problems, but consistent practice helped me perform well. My advice to future candidates is to practice consistently and focus on understanding core concepts rather than just memorizing solutions.

88

Company Name: Amazon

Position: Software Developer Intern

Location: Hyderabad

Application Process: Applied through campus placement

Interview Rounds:

  • Round 1 - Video Call (Technical):

    • Questions Asked:
      1. Spiral Order Traversal of a Binary Tree: Given a binary tree, print its nodes in spiral order.
      2. Row Of A Matrix With Maximum Ones: Given a 2D matrix with sorted rows (each row contains '0’s followed by '1’s), find the row with the maximum number of '1’s.
    • Your Approach:
      • For the binary tree problem, I used a level-order traversal with a flag to alternate the direction of traversal.
      • For the matrix problem, I leveraged the sorted property of rows to count the '1’s efficiently using binary search.
    • Outcome: Passed this round.

  • Round 2 - Video Call (Technical):

    • Questions Asked:
      1. Sort An Array According To The Count Of Set Bits: Given an array of integers, sort it in decreasing order based on the count of set bits in their binary representation.
      2. Rotting Oranges: Given a grid representing oranges (0 for empty, 1 for fresh, 2 for rotten), determine the minimum time required for all oranges to rot.
    • Your Approach:
      • For the set bits problem, I used a custom comparator to sort the array based on the count of set bits.
      • For the rotting oranges problem, I applied a BFS approach to simulate the rotting process and calculate the time.
    • Outcome: Passed this round and was selected for the internship.

Preparation Tips:

  • Focus on mastering Data Structures and Algorithms (DSA) topics like Dynamic Programming, Stacks, Arrays, Linked Lists, Binary Trees, and Divide and Conquer.
  • Practice competitive programming to improve problem-solving speed.
  • Work on projects to showcase practical skills and prepare to discuss them in detail.

Conclusion:
The interviewers were friendly and made the process comfortable. The questions were medium difficulty, and my preparation in DSA and competitive programming helped me perform well. For future candidates, I recommend being thorough with the basics and practicing company-specific problems.

89

Company Name: Amazon

Position: Software Developer Intern

Application Process: I applied through the campus placement process in December 2020.

Interview Rounds:

  • Round 1 - Coding Test:

  • Questions Asked:

    1. Merge Two Sorted Linked Lists: Given two sorted linked lists, merge them into a single sorted linked list.
    2. Rat In A Maze: Solve the maze problem where the rat starts at (0, 0) and needs to find a path to the destination.
    3. Two Sum: Find all pairs in an array that sum up to a given target.

  • Your Approach: For the linked list problem, I used a two-pointer approach to merge the lists efficiently. For the maze problem, I implemented backtracking. The two-sum problem was straightforward using a hash map.

  • Outcome: Passed this round.

  • Round 2 - Video Call (Technical):

  • Questions Asked:

    1. Longest Increasing Subsequence: Find the length of the longest increasing subsequence in an array.
    2. Boundary Traversal of Binary Tree: Print the boundary nodes of a binary tree in an anti-clockwise direction.
    3. Spiral Matrix: Traverse a matrix in a spiral order.

  • Your Approach: For the LIS problem, I used dynamic programming. The boundary traversal required careful handling of tree nodes, and the spiral matrix problem was solved using layer-by-layer traversal.

  • Outcome: Cleared this round successfully.

  • Round 3 - Video Call (Technical + HR):

  • Questions Asked:

    1. OS Questions: Threads vs. processes, what is an operating system, and memory management.
    2. DBMS Questions: Normal forms and SQL queries.

  • Your Approach: I explained the differences between threads and processes clearly and discussed memory management techniques. For DBMS, I provided examples of normalization and wrote a few SQL queries.

  • Outcome: Selected for the internship.

Preparation Tips:

  • Topics to focus on: Data Structures and Algorithms, OS, DBMS, CN, and OOPs concepts.
  • Time required: 3 months of dedicated preparation.
  • Tips:
    1. Keep your resume concise and highlight achievements.
    2. Practice previous Amazon interview questions.
    3. Stay calm and confident during the interview.

Conclusion:
Overall, the interview process was smooth, and the questions were aligned with my preparation. I could have practiced more on tree and graph problems, but my strong grasp of DSA and core CS concepts helped me secure the internship. For future candidates, focus on problem-solving and clarity of concepts.

90

Company Name: Amazon

Position: Software Developer Intern

Application Process: I was interviewed in December 2020. The process included an online coding test followed by two video call rounds.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Favourite Operation: Ninja has recently studied operators ‘AND’ and ‘XOR’. The task was to calculate the bitwise ‘AND’ of all subarrays of size at most ‘K’ and then take the bitwise ‘XOR’ of all these ‘AND’ results.
      2. Critical Connection: Given a network with ‘N’ system nodes and ‘M’ connections, the task was to find all critical connections in the network.
    • Your Approach: For the first question, I focused on efficiently calculating the bitwise ‘AND’ for subarrays and then XORing the results. For the second question, I used graph traversal techniques to identify critical connections.
    • Outcome: Passed this round and moved to the next stage.

  • Round 2 - Video Call (Technical):

    • Questions Asked:
      1. Product Of Array Except Self: Given an integer array, return an array where each element is the product of all elements except itself.
    • Your Approach: I solved this by using prefix and suffix products to avoid division and handle the problem in linear time.
    • Outcome: The interviewer was supportive, and I passed this round.

  • Round 3 - Video Call (Technical):

    • Questions Asked:
      1. LRU Cache Implementation: Design and implement a data structure for Least Recently Used (LRU) cache supporting get and put operations.
    • Your Approach: I implemented the LRU cache using a combination of a hash map and a doubly linked list to achieve O(1) time complexity for both operations.
    • Outcome: The interviewer was strict about time, and a shadow interviewer was present. Unfortunately, I was rejected after this round.

Preparation Tips:

  • Topics to Focus On: LinkedList, Trees, Graphs, Dynamic Programming, Arrays, DBMS, OS, OOPS.
  • Resources: Practice different and quality questions from LeetCode and InterviewBit.
  • Time Required: Dedicate at least 6 months for thorough preparation.

Conclusion:
Overall, the interview process was challenging but a great learning experience. The coding test was tough, but the video call rounds were more interactive. I could have managed my time better in the final round. For future candidates, I recommend practicing problem-solving under time constraints and being confident about your resume details.

91

Company Name: Amazon

Position: Software Developer Intern

Location: Hyderabad

Application Process: I applied for the job as an SDE Intern through the campus placement process. The eligibility criteria included pursuing a bachelor’s in CS/IT with a CGPA above 6.5.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Position of Right Most Set Bit: Given a number N, return the position of the rightmost set bit in its binary representation.
      2. Ninja’s Jump: A problem involving reaching the last stone in an array with specific constraints.
    • Your Approach: For the first question, I used bit manipulation to find the rightmost set bit. For the second question, I applied dynamic programming to solve the problem efficiently.
    • Outcome: Passed this round and moved to the next stage.

  • Round 2 - Telephonic Call:

    • Questions Asked:
      1. Count Ways To Reach The N-th Stairs: A dynamic programming problem to count the number of ways to reach the Nth stair.
      2. Camel and Banana Puzzle: A puzzle involving transporting bananas using a camel with specific constraints.
    • Your Approach: For the first question, I used dynamic programming to count the ways. For the puzzle, I worked through the constraints logically to find the optimal solution.
    • Outcome: Successfully cleared this round.

  • Round 3 - HR Round:

    • Questions Asked:
      1. Basic HR questions like willingness to relocate, knowledge about Amazon, and long-term plans with the company.
    • Your Approach: I answered honestly and confidently, ensuring I highlighted my enthusiasm for the role and company.
    • Outcome: The round went well, and the interviewer and I had a pleasant conversation.

Preparation Tips:

  • Topics to Prepare: Data Structures, Trees and Graphs, Arrays, Backtracking, Pointers, OOPS, System Design, Greedy Algorithms, Dynamic Programming.
  • Resources: Solved must-do questions on GeeksforGeeks, practiced on Codechef and Codeforces, and took a placement preparation course from Coding Ninjas.
  • Tips:
    1. Solve all must-do questions available on GeeksforGeeks.
    2. Having a team project on your resume can give you an edge.
    3. Regularly practice on competitive coding platforms to build a strong profile.
    4. Mention links to your competitive profiles in your resume.

Conclusion:
Overall, the interview experience was challenging but rewarding. The key was thorough preparation and confidence during the interviews. I would advise future candidates to focus on problem-solving and clear communication. Additionally, having a well-prepared resume with relevant projects and competitive coding profiles can make a significant difference.

92

Company Name: Amazon

Position: Software Developer Intern

Application Process: The interview process was conducted before September 2020 and consisted of 4 rounds: a coding test followed by three video call rounds.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Check Subset: Given two integer arrays, determine if the second array is a subset of the first.
      2. Kth Smallest and Largest Element of Array: Find the Kth smallest and largest elements in an array.
    • Your Approach: For the subset problem, I used a hash set to check for the presence of elements. For the Kth element problem, I sorted the array and directly accessed the required indices.
    • Outcome: Passed the round.

  • Round 2 - Video Call (Technical):

    • Questions Asked:
      1. Longest Path in a DAG: Find the longest path in a Directed Acyclic Graph.
      2. LRU Cache Implementation: Design and implement an LRU cache.
    • Your Approach: For the DAG problem, I used topological sorting and dynamic programming. For the LRU cache, I implemented it using a doubly linked list and a hash map.
    • Outcome: Passed the round.

  • Round 3 - Video Call (Technical):

    • Questions Asked:
      1. String Transformation: Transform a string by repeatedly taking the smallest character and appending it to a new string.
    • Your Approach: I used a priority queue to efficiently retrieve the smallest character at each step.
    • Outcome: Passed the round.

  • Round 4 - Video Call (Technical):

    • Questions Asked:
      1. Sorted Linked List to Balanced BST: Convert a sorted linked list into a balanced binary search tree.
      2. Delete Mid Element from Stack: Delete the middle element of a stack.
    • Your Approach: For the BST problem, I used a recursive approach to balance the tree. For the stack problem, I used an auxiliary stack to track and remove the middle element.
    • Outcome: Passed the round and received the internship offer.

Preparation Tips:

  • Focus on Data Structures and Algorithms, especially graphs, dynamic programming, and system design.
  • Practice coding problems regularly on platforms like LeetCode and GeeksforGeeks.
  • Be thorough with core CS concepts like Operating Systems, DBMS, and OOPs.
  • Time management is crucial during coding rounds, so practice under timed conditions.

Conclusion:
The interview process was challenging but rewarding. The interviewers were supportive and provided hints when needed. I could have improved by practicing more graph-related problems beforehand. For future candidates, I recommend consistent coding practice and a strong grasp of fundamental concepts.

93

Company Name: Amazon

Position: Software Developer Intern

Application Process: The interview process was conducted before September 2020 and consisted of 4 rounds: a coding test followed by three video call rounds.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Check Subset: Given two integer arrays, determine if the second array is a subset of the first.
      2. Kth Smallest and Largest Element of Array: Find the Kth smallest and largest elements in a given array.
    • Your Approach: For the subset problem, I used a hash set to efficiently check for subset elements. For the Kth element problem, I sorted the array and then directly accessed the required elements.
    • Outcome: Passed the round.

  • Round 2 - Video Call (Technical):

    • Questions Asked:
      1. Longest Path in a DAG: Given a Directed Acyclic Graph, find the longest path.
      2. LRU Cache Implementation: Design and implement an LRU cache.
    • Your Approach: For the DAG problem, I used topological sorting and dynamic programming. For the LRU cache, I implemented a combination of a hash map and a doubly linked list.
    • Outcome: Passed the round.

  • Round 3 - Video Call (Technical):

    • Questions Asked:
      1. String Transformation: Given a string, transform it by repeatedly taking the smallest character and appending it to a new string.
    • Your Approach: I used a priority queue to efficiently manage the smallest character selection.
    • Outcome: Passed the round.

  • Round 4 - Video Call (Technical):

    • Questions Asked:
      1. Sorted Linked List to Balanced BST: Convert a sorted linked list into a balanced binary search tree.
      2. Delete Mid Element from Stack: Delete the middle element of a stack.
    • Your Approach: For the BST problem, I used a recursive approach to balance the tree. For the stack problem, I used an auxiliary stack to track and remove the middle element.
    • Outcome: Passed the round and was selected for the internship.

Preparation Tips:

  • Focus on mastering Data Structures and Algorithms, especially graphs, trees, and dynamic programming.
  • Practice coding regularly on platforms like LeetCode or HackerRank.
  • Be thorough with core CS concepts like Operating Systems, DBMS, and OOP.
  • Work on problem-solving skills and understand the time and space complexities of your solutions.

Conclusion:
The interview process was challenging but fair. The interviewers were supportive and provided hints when needed. I could have prepared better for core CS concepts, but my strong DSA foundation helped me succeed. My advice to future candidates is to practice consistently and understand the underlying principles of each problem.

94

Company Name: Amazon

Position: Software Developer Intern

Application Process: I was interviewed before September 2020. The process consisted of 4 rounds: a coding test and three video call interviews.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Check Subset: Given two integer arrays, determine if the second array is a subset of the first.
      2. Kth Smallest and Largest Element of Array: Find the Kth smallest and largest elements in an array.
    • Your Approach: For the subset problem, I used a hash set to efficiently check for the presence of elements. For the Kth element problem, I sorted the array and directly accessed the required elements.
    • Outcome: Passed this round.

  • Round 2 - Video Call (Technical):

    • Questions Asked:
      1. Longest Path in a DAG: Given a Directed Acyclic Graph, find the longest path.
      2. LRU Cache Implementation: Design and implement an LRU cache.
    • Your Approach: For the DAG problem, I used topological sorting and dynamic programming. For the LRU cache, I implemented it using a doubly linked list and a hash map for O(1) operations.
    • Outcome: Passed this round.

  • Round 3 - Video Call (Technical):

    • Questions Asked:
      1. String Transformation: Given a string, transform it by repeatedly taking the smallest character and appending it to a new string.
    • Your Approach: I used a priority queue to efficiently manage the smallest character selection.
    • Outcome: Passed this round.

  • Round 4 - Video Call (Technical):

    • Questions Asked:
      1. Sorted Linked List to Balanced BST: Convert a sorted linked list into a balanced binary search tree.
      2. Delete Mid Element from Stack: Delete the middle element of a stack.
    • Your Approach: For the BST problem, I used a recursive approach to ensure balance. For the stack problem, I used an auxiliary stack to track and remove the middle element.
    • Outcome: Passed this round and was selected for the internship.

Preparation Tips:

  • Focus on Data Structures and Algorithms, especially graphs, dynamic programming, and system design.
  • Practice coding problems on platforms like LeetCode and GeeksforGeeks.
  • Be thorough with C++ and OOP concepts, as they were frequently discussed.
  • Understand the complexities of your solutions and be ready to explain them.

Conclusion:
The interview process was challenging but fair. The interviewers were supportive and provided hints when needed. I could have prepared more for system design questions, but overall, my problem-solving skills and conceptual clarity helped me succeed. My advice to future candidates is to practice consistently and understand the underlying principles of each problem.