Amazon Software Developer Intern Interview Questions & Experience Guide

Interview Preparation
,
61

Company Name: Amazon

Position: Software Developer Intern

Location: Bangalore

Application Process: Applied through the university placement process.

Interview Rounds:

  • Round 1 - Coding Test:

  • Questions Asked:

    1. Remainder When Divided By 11: Given a very large number N (as a string), find the remainder when N is divided by 11.
    2. Missing Number: Given an array of distinct strings representing integers from 0 to N in binary, find the missing integer.

  • Your Approach: For the first question, I used the divisibility rule of 11 to compute the remainder efficiently. For the second question, I converted binary strings to integers and checked for the missing number.

  • Outcome: Passed this round.

  • Round 2 - Face to Face Interview:

  • Questions Asked:

    1. Fish Eater: Given an array of fishes in a river, simulate their movement and interactions based on certain rules.
    2. Fishmonger: A problem involving traversing states with tolls and optimizing the path for minimum cost.

  • Your Approach: For the first question, I simulated the fish movements using a stack. For the second, I applied dynamic programming to minimize the toll cost.

  • Outcome: The interviewer was satisfied with my approach, and I passed this round.

  • Round 3 - Face to Face Interview:

  • Questions Asked:

    1. Battalions and Tanks: Given battalions of soldiers and tanks, allocate tanks optimally based on certain constraints.
    2. Diagonal Traversal of a Binary Tree: Traverse a binary tree diagonally and return the nodes in order.

  • Your Approach: For the first question, I used a greedy algorithm to allocate tanks. For the second, I implemented a level-order traversal with a hash map to track diagonal levels.

  • Outcome: The interviewer appreciated my problem-solving skills, and I cleared this round.

Preparation Tips:

  • Focus on understanding the core concepts of data structures and algorithms.
  • Practice coding problems from various platforms to get comfortable with different problem types.
  • Ensure your resume is concise (1 page) and reflects your skills accurately.

Conclusion:
Overall, the interview experience was positive. The interviewers were friendly and focused on problem-solving skills. I could have practiced more dynamic programming problems beforehand. My advice to future candidates is to thoroughly understand the basics and practice consistently.

62

Company Name: Amazon

Position: Software Developer Intern

Location: Hyderabad

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

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Total Unique Paths: Given an M x N matrix, find the total number of unique paths from the top-left cell to the bottom-right cell, moving only right or down.
      2. Longest Increasing Subsequence: For a given array, find the length of the longest subsequence such that all elements are in increasing order.
    • Your Approach: For the first question, I used dynamic programming to calculate the number of paths. For the second question, I implemented a dynamic programming solution to track the longest increasing subsequence.
    • Outcome: Passed the round with both questions solved optimally.

  • Round 2 - Video Call (Technical Interview):

    • Questions Asked:
      1. Maximum Product Subarray: Find the contiguous subarray within an array that has the largest product.
      2. Height of the Binary Tree: Given the inorder and level order traversal of a binary tree, calculate its height.
      3. Find Missing Number in String: Given a string of concatenated numbers, find the missing number in the sequence.
    • Your Approach: For the first question, I used dynamic programming to track the maximum and minimum products. For the second question, I reconstructed the tree and then calculated its height. The third question involved parsing the string and identifying the missing number by checking the sequence.
    • Outcome: Solved all three questions, but unfortunately, I was rejected in the final outcome.

Preparation Tips:

  • Regular coding practice on platforms like GFG, Leetcode, and Coding Ninjas. Don’t get discouraged if you don’t solve a problem in one try—keep trying!
  • Be confident and maintain at least 2 projects in your resume.
  • Even if you’re stuck during the interview, give it your best shot. The interviewer will likely help you out.

Conclusion:
Overall, the interview experience was challenging but rewarding. I learned the importance of thorough preparation and staying calm under pressure. For future candidates, I’d advise focusing on dynamic programming and tree-related problems, as they were heavily emphasized in my rounds. Keep practicing and don’t lose hope!

63

Company Name: Amazon

Position: Software Developer Intern

Location: Bangalore

Application Process: Applied through campus placement with eligibility criteria of above 6.5 CGPA and no backlogs.

Interview Rounds:

  • Round 1 - Coding Test:

  • Questions Asked:

    • Count inversions in an array.
    • Find pair with maximum GCD in an array.

  • Your Approach:

    • For the inversion count, I used a modified merge sort approach to efficiently count inversions.
    • For the GCD problem, I iterated through the array to find the pair with the highest GCD.

  • Outcome: Cleared the round.

  • Round 2 - Video Call (Technical):

  • Questions Asked:

    • Array Queries: Given an array of size n, perform q queries.
    • Majority element in an array.
    • Subarray with equal occurrences of 0s and 1s.

  • Your Approach:

    • For the array queries, I used prefix sums to optimize the solution.
    • For the majority element, I used the Boyer-Moore voting algorithm.
    • For the subarray problem, I used a hashmap to track the balance of 0s and 1s.

  • Outcome: Cleared the round.

  • Round 3 - Video Call (Technical):

  • Questions Asked:

    • Convert a sorted linked list to a balanced BST.
    • Implement a stack using a linked list.

  • Your Approach:

    • For the linked list to BST problem, I used a recursive approach to find the middle element and build the tree.
    • For the stack implementation, I ensured all stack operations (push, pop, peek) were O(1) time complexity.

  • Outcome: Cleared the round and got selected.

Preparation Tips:

  • Topics to focus on: Data Structures and Algorithms, OOPS, DBMS, Computer Networks, Operating System.
  • Practice a variety of problems rather than sticking to one type.
  • Be thorough with your projects and resume details.

Conclusion:
The interviewers were supportive, and the questions were fair. I could have practiced more on optimizing my solutions further. My advice is to stay consistent with your preparation and be confident in your answers.

64

Company Name: Amazon

Position: Software Developer Intern

Application Process: I was interviewed before September 2020. The process included a coding test followed by a video call interview round.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Maximum Path Sum in the Matrix: Given an N*M matrix, find the maximum sum obtained from a path starting from any cell in the first row to any cell in the last row. Moves allowed: down, down-left diagonal, or down-right diagonal.
      2. Dice Throws: Given D dice, each with F faces, find the number of ways to roll the dice together to get a specific sum.
    • Your Approach: For the matrix problem, I used dynamic programming to track the maximum path sum from each cell. For the dice problem, I employed a combinatorial approach with memoization to count the valid outcomes.
    • Outcome: Qualified for the next round by solving both problems completely.

  • Round 2 - Video Call Interview:

    • Questions Asked:
      1. Palindrome Permutation: Check if any permutation of a given string can form a palindrome.
      2. Longest Common Subsequence: Find the length of the longest common subsequence between two strings.
    • Your Approach: For the palindrome problem, I checked the frequency of characters to determine if a palindrome permutation was possible. For the LCS problem, I implemented a dynamic programming solution to compare the strings.
    • Outcome: The round was challenging, and unfortunately, I was rejected after this stage.

Preparation Tips:

  • Focus on Dynamic Programming, Trees, Graphs, Linked Lists, and OOPs concepts.
  • Practice solving programming questions with attention to constraints before coding.
  • Aim for optimal solutions in your practice sessions.

Conclusion:
Overall, the interview process was rigorous but a great learning experience. I realized the importance of optimizing solutions and handling edge cases. For future candidates, I recommend thorough preparation in data structures and algorithms, along with consistent problem-solving practice.

65

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:

    • Debugging: 7 problems involving logical error fixes in code snippets.
    • Reasoning Ability: Verbal reasoning and aptitude questions.
    • Coding:
      1. Search in a row-wise and column-wise sorted matrix.
      2. Clone a linked list with a random pointer.

  • Your Approach: For the coding problems, I focused on optimizing the search for the matrix problem by leveraging the sorted property. For the linked list problem, I used a hash map to map original nodes to their clones.

  • Outcome: Cleared the round and was shortlisted for the next stage.

  • Round 2 - Video Call (Technical Interview):

  • Questions Asked:

    1. Return in Row wave form: Read a 2D array row-wise and return a linear array in wave form.
    2. Construct a strict binary tree from a given preorder traversal array.

  • Your Approach: For the wave form problem, I iterated through the matrix row-wise and alternated the direction for each row. For the binary tree problem, I used recursion to construct the tree from the preorder array.

  • Outcome: Successfully answered both questions and advanced to the next round.

  • Round 3 - Video Call (Technical Interview):

  • Questions Asked:

    1. Alien Dictionary: Determine the order of characters in an alien language from a sorted dictionary.

  • Your Approach: I modeled the problem as a graph and used topological sorting to find the character order.

  • Outcome: Answered the question well and received positive feedback.

Preparation Tips:

  • Focus on Data Structures, Algorithms, OOPS, DBMS, OS, and Networks.
  • Practice coding problems regularly and speak your thought process aloud during interviews.
  • Mention only what you know on your resume; competitive programming ranks are a plus.

Conclusion:
Overall, the interview experience was challenging but rewarding. I felt well-prepared for the technical rounds, but I could have practiced more on graph problems beforehand. My advice to future candidates is to stay confident, articulate your approach clearly, and ensure a strong grasp of core CS concepts.

66

Company Name: Amazon

Position: Software Developer Intern

Location: Hyderabad

Application Process: Applied through the Amazewow process via Amazewit (https://www.amazewit.in/) before September 2020. The process included a coding test followed by two video call rounds.

Interview Rounds:

  • Round 1 - Coding Test:

  • Questions Asked:

    1. Longest Decreasing Subsequence: Given an array, find the length of the longest decreasing subsequence.
    2. Next Greater Element: For each element in an array, find the next greater element.

  • Your Approach: For the first question, I used dynamic programming to solve it in O(N log N) time complexity. For the second question, I used a stack-based approach to find the next greater element efficiently.

  • Outcome: Passed the round.

  • Round 2 - Video Call (Technical):

  • Questions Asked:

    1. Students in a Row: Given an array of weights, find the position of a child such that all lighter children are to their left and heavier to their right.
    2. Transform BST to Greater Sum Tree: Convert a BST such that each node’s value is replaced by the sum of all nodes greater than it.

  • Your Approach: For the first question, I iterated through the array to find the pivot point. For the second question, I performed a reverse in-order traversal to accumulate the sum.

  • Outcome: The interviewer was friendly and provided hints. Passed the round.

  • Round 3 - Video Call (Technical):

  • Questions Asked:

    1. Time to Burn Tree: Given a binary tree and a start node, calculate the time taken to burn the entire tree.
    2. Distance Between Nodes: Find the distance between two given nodes in a binary tree.

  • Your Approach: For the first question, I used BFS to simulate the burning process. For the second question, I found the lowest common ancestor (LCA) and then calculated the distance from the LCA to both nodes.

  • Outcome: The interviewer was supportive and provided hints. However, I was rejected in this round.

Preparation Tips:

  • Topics to Focus On: Data Structures (especially Trees and Arrays), Algorithms, OOPS, and Operating Systems.
  • Practice: Code regularly on platforms like LeetCode and GeeksforGeeks.
  • Confidence: Stay calm and confident during the interview.

Conclusion:
Overall, the interview process was rigorous but a great learning experience. The interviewers were friendly and provided hints when needed. I realized the importance of practicing tree-related problems more thoroughly. For future candidates, I recommend focusing on problem-solving skills and understanding core concepts deeply.

67

Company Name: Amazon

Position: Software Developer Intern

Location: Bangalore

Application Process: Applied through campus placement.

Interview Rounds:

  • Round 1 - Coding Test:

  • Questions Asked:

    • Debugging section with 7 questions (20 minutes).
    • 2 coding questions (70 minutes):
      1. Merge Two Sorted Linked Lists.
      2. Word Break problem.
    • Behavioural section.
    • 35 reasoning-based questions (24 minutes).

  • Your Approach: Focused on debugging the given code snippets for the first section. For the coding questions, I used a two-pointer approach for the linked list problem and dynamic programming for the word break problem.

  • Outcome: Cleared the round successfully.

  • Round 2 - Video Call (Technical Interview):

  • Questions Asked:

    1. Add two numbers as linked lists.
    2. Course Schedule problem.
    3. Explain ACID properties in DBMS.
    4. How does a URL work?

  • Your Approach: Discussed my projects briefly before diving into the technical questions. For the linked list problem, I used iterative traversal. For the course schedule, I explained topological sorting. For DBMS and networking, I provided concise definitions and examples.

  • Outcome: Selected for the internship.

Preparation Tips:

  • Topics to Prepare: Data Structures, DBMS, OOPS, Computer Networks, Algorithms, Dynamic Programming.
  • Time Required: 4 months.
  • Tips:
    1. Practice problem-solving regularly.
    2. Work on at least 2 projects to showcase practical skills.
    3. Avoid grammatical errors in your resume and keep it concise.

Conclusion:
Overall, the interview process was smooth and well-structured. The key to success was thorough preparation and clarity of concepts. For future candidates, I’d recommend focusing on problem-solving and understanding core CS fundamentals.

68

Company Name: Amazon

Position: Software Developer Intern

Location: Not specified

Application Process: The candidate was interviewed before September 2020. The process included an online coding test followed by a face-to-face interview round.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Palindrome Linked List: Check if a given singly linked list is a palindrome. Follow-up: Solve in O(N) time and O(1) space iteratively.
      2. Total Unique Paths: Find the number of unique paths from the top-left to the bottom-right of an M x N matrix.
    • Your Approach: The candidate solved the problems using data structures and algorithms, focusing on optimizing time and space complexity.
    • Outcome: Passed the round.

  • Round 2 - Face-to-Face Interview:

    • Questions Asked:
      1. Find Number of Islands: Given a 2D array of 1s (land) and 0s (water), count the number of islands.
      2. DBMS Concepts: Explain ACID properties and different types of joins (Natural, Cross, Left, Right).
      3. OOPS Concepts: Define copy constructor, encapsulation, and abstraction.
    • Your Approach: The candidate confidently answered the questions, leveraging their knowledge of data structures, DBMS, and OOPS concepts. The interviewer provided hints when needed.
    • Outcome: Selected for the role.

Preparation Tips:

  • Topics to Focus On: C++, Data Structures (especially trees and graphs), Dynamic Programming, Algorithms, Operating Systems, OOPS, DBMS, and Computer Networks.
  • Practice: Solve 5-6 coding questions daily on platforms like LeetCode and GeeksForGeeks. Analyze time and space complexity for each solution.
  • Resources: Refer to GeeksForGeeks articles and Coding Ninja’s Data Structures and Algorithms course for OOPS concepts.

Application Resume Tips:

  • Only include skills, projects, or achievements you are thoroughly familiar with.
  • Quality over quantity: One well-executed project is sufficient.
  • Highlight achievements that demonstrate technical skills, communication, leadership, or teamwork.

Conclusion:
The candidate successfully cleared the interview by focusing on strong fundamentals, consistent practice, and clear communication. They recommend thorough preparation and confidence in answering questions to future candidates.

69

Company Name: Amazon

Position: Software Developer Intern

Location: Not specified

Application Process: The interview was conducted before September 2020. The eligibility criteria included being from circuital branches only or being female. The application process involved receiving a link to apply, and resumes were not shortlisted; the link was sent to everyone meeting the eligibility criteria.

Interview Rounds:

  • Round 1 - Video Call (Technical Interview):
    • Questions Asked:
      1. Matrix Median: Given a matrix of ‘N’ rows and ‘M’ columns with every row sorted in non-decreasing order, find the overall median of the matrix. The median is the middle number when all elements are listed in order. Constraints included ‘N’ and ‘M’ being up to 100, and ‘N’ * ‘M’ always being odd.
      2. Count Triplets in a Sorted Doubly Linked List: Given a sorted doubly linked list and an integer ‘X’, count all triplets in the list whose sum equals ‘X’.
    • Your Approach:
      • For the Matrix Median, I first considered the properties of a sorted matrix and how to efficiently find the median without explicitly listing all elements. I discussed a binary search approach to narrow down the median value.
      • For the Count Triplets problem, I leveraged the sorted nature of the doubly linked list and used a two-pointer technique to find triplets efficiently.
    • Outcome: I was able to solve both problems and explain my logic clearly. The interviewer seemed satisfied with my approach and solutions.

Preparation Tips:

  • Topics to Focus On: Data Structures, Algorithms, Object-Oriented Programming (OOP), Dynamic Programming (DP), and Pointers.
  • Time Required: Approximately 2 months of dedicated preparation.
  • Tips:
    1. Practice explaining your logic clearly during interviews.
    2. Learn to dry-run your code to ensure correctness.
    3. Solve as many data structure problems as possible to build confidence.

Conclusion:
Overall, the interview experience was positive. The questions were challenging but manageable with proper preparation. I focused on explaining my thought process clearly and efficiently solving the problems. For future candidates, I recommend practicing a variety of problems and ensuring you can articulate your solutions well. The key is to stay calm and methodical during the interview.

70

Company Name: Amazon

Position: Software Developer Intern

Location: Hyderabad

Application Process:
I applied for the job as an SDE Intern through campus placements. The eligibility criteria included having a CGPA above 7.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Search in a row-wise and column-wise sorted matrix: Given an N x N matrix sorted in increasing order, find the position of a target integer ‘X’.
      2. Clone Linked List with Random Pointer: Given a linked list with two pointers in each node (one pointing to the next node and the other random), clone the list.
    • Your Approach:
      • For the matrix problem, I used a binary search approach to efficiently locate the target.
      • For the linked list problem, I used a hashmap to map original nodes to their clones, ensuring the random pointers were correctly set.
    • Outcome: Cleared the round and was shortlisted for the next stage.

  • Round 2 - Video Call (Technical):

    • Questions Asked:
      1. Row Wave Form: Given a 2D array, read the elements row-wise and return a linear array in a wave pattern.
      2. Construct a strict binary tree: Given a preorder traversal array, construct a strict binary tree.
    • Your Approach:
      • For the wave form problem, I iterated through the matrix row-wise and alternated the direction of traversal for each row.
      • For the binary tree problem, I used recursion to build the tree from the preorder array.
    • Outcome: Successfully answered both questions and advanced to the next round.

  • Round 3 - Video Call (Technical):

    • Questions Asked:
      1. Alien Dictionary: Given a sorted dictionary of an alien language, determine the order of characters.
    • Your Approach:
      • I used topological sorting to deduce the character order based on the given dictionary.
    • Outcome: Answered the question well and was selected for the internship.

Preparation Tips:

  • Topics to Focus On: Data Structures, Algorithms, OOPS, DBMS, OS, and Networks.
  • Time Required: 4 months of dedicated preparation.
  • Additional Tips:
    1. Practice data structures and algorithms regularly.
    2. Be confident and articulate your thought process clearly.
    3. Competitive programming ranks can be a plus.

Conclusion:
Overall, the interview experience was challenging but rewarding. I felt well-prepared for the technical rounds, but I could have practiced more on system design concepts. My advice to future candidates is to focus on problem-solving and clarity of thought during interviews. Good luck!

71

Company Name: Amazon

Position: Software Developer Intern

Location: Not specified

Application Process: Applied online before September 2020.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Minimum Cost to Cross Grid: Given a 2-D grid with costs, find the minimum total cost to move from the top-left to the bottom-right cell.
      2. Sub Matrices With Sum Zero: Given a square matrix, count the number of non-empty sub-matrices with a sum of zero.
    • Your Approach: For the first question, I used Dijkstra’s algorithm to find the minimum cost path. For the second question, I employed dynamic programming to count sub-matrices efficiently.
    • Outcome: Passed the round.

  • Round 2 - Video Call Interview:

    • Questions Asked:
      1. Print Boundary Values of the Binary Tree: Print the boundary nodes of a binary tree in an anti-clockwise manner.
      2. Segregate Even and Odd Nodes in a Linked List: Modify a linked list to segregate even and odd nodes.
    • Your Approach: For the binary tree question, I traversed the tree in a specific order to capture boundary nodes. For the linked list problem, I used two pointers to separate even and odd nodes.
    • Outcome: The interviewer was friendly, but I was rejected after this round.

Preparation Tips:

  • Topics to Prepare: Data Structures, Algorithms, Operating System, DBMS, OOPS.
  • Time Required: 7-8 months of consistent preparation.
  • Tips:
    1. Create a timetable and set daily goals. Dedicate 3-4 hours to studying. Consistency is key.
    2. Complete at least 2 projects to showcase practical skills.
    3. Understand the complexities of the code you write.

Conclusion:
Overall, the interview process was challenging but insightful. I could have practiced more problem-solving under time constraints. For future candidates, I recommend focusing on core concepts and maintaining a steady preparation routine.

72

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:
      1. Debugging: 7 problems with logical errors to rectify.
      2. Reasoning Ability: Verbal reasoning and aptitude questions.
      3. Coding:
        • Q1. Search in a row-wise and column-wise sorted matrix.
        • Q2. Clone Linked List with Random Pointer.
    • Your Approach: Focused on debugging efficiently and solving the coding problems using optimal algorithms.
    • Outcome: Cleared the round and was shortlisted for the next stage.

  • Round 2 - Video Call (Technical):

    • Questions Asked:
      1. Return in Row wave form.
      2. Construct a strict binary tree from preorder traversal.
    • Your Approach: Explained the logic clearly and coded the solutions while discussing the approach.
    • Outcome: Advanced to the next round.

  • Round 3 - Video Call (Technical):

    • Questions Asked:
      1. Alien Dictionary problem (finding the order of characters in an alien language).
    • Your Approach: Discussed the graph-based solution and implemented it step-by-step.
    • Outcome: Successfully cleared the round and was selected for the internship.

Preparation Tips:

  • Focus on Data Structures, Algorithms, OOPS, DBMS, OS, and Networks.
  • Practice coding problems regularly and participate in competitive programming.
  • Be confident and articulate your thought process clearly during interviews.

Conclusion:
The interview process was challenging but rewarding. Practicing consistently and understanding core concepts helped me perform well. My advice to future candidates is to stay calm, think aloud, and be thorough with the basics.

73

Company Name: Amazon

Position: Software Developer Intern

Location: Hyderabad

Application Process: Applied through the Amazewow process via Amazewit (https://www.amazewit.in/) before September 2020.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Longest Decreasing Subsequence: Given an array, find the length of the longest decreasing subsequence.
      2. Next Greater Element: For each element in an array, find the next greater element.
    • Your Approach: Solved both problems using dynamic programming and stack-based approaches, respectively. Focused on optimizing for O(N log N) time complexity for the first question.
    • Outcome: Cleared the round.

  • Round 2 - Video Call (Technical):

    • Questions Asked:
      1. Students are standing in a row; given their weights, find the position of a child such that all lighter students are to their left.
      2. Transform BST to a greater sum tree.
    • Your Approach: Used array traversal for the first question and a reverse in-order traversal for the BST problem. The interviewer provided hints, which were very helpful.
    • Outcome: Cleared the round.

  • Round 3 - Video Call (Technical):

    • Questions Asked:
      1. Time to Burn Tree: Given a binary tree and a start node, calculate the time taken to burn the entire tree.
      2. Distance between nodes of a binary tree.
    • Your Approach: Used BFS for the burning tree problem and LCA (Lowest Common Ancestor) for calculating node distances. The interviewer was supportive and provided hints.
    • Outcome: Rejected after this round.

Preparation Tips:

  • Focus on Data Structures (especially Trees and Arrays).
  • Practice coding problems on platforms like LeetCode and GeeksforGeeks.
  • Be confident and clear in explaining your thought process during interviews.

Conclusion:
Overall, the interview experience was positive. The interviewers were friendly and provided hints when needed. I could have practiced more complex tree problems to better handle the final round. For future candidates, I recommend thorough preparation in Data Structures and Algorithms, especially Trees and Graphs.

74

Company Name: Amazon

Position: Software Developer Intern

Location: Not specified

Application Process: The candidate was interviewed before September 2020. The process included an online coding test followed by a face-to-face interview round.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Palindrome Linked List: Determine if a given singly linked list is a palindrome. Follow-up: Solve it in O(N) time and O(1) space iteratively.
      2. Total Unique Paths: Find the number of unique paths from the top-left to the bottom-right cell of an M x N matrix.
    • Your Approach: The candidate solved the problems using data structures and algorithms, focusing on optimizing time and space complexity.
    • Outcome: The candidate successfully completed the coding test.

  • Round 2 - Face to Face Interview:

    • Questions Asked:
      1. Find Number of Islands: Given a 2D array of 1s (land) and 0s (water), count the number of islands.
      2. DBMS Concepts: Explain ACID properties and different types of joins (Natural, Cross, Left, Right).
      3. OOPS Concepts: Define copy constructor, encapsulation, and abstraction.
    • Your Approach: The candidate confidently answered the questions, leveraging their knowledge of data structures, DBMS, and OOPS concepts. The interviewer provided hints when needed.
    • Outcome: The candidate performed well and was selected for the internship.

Preparation Tips:

  • Topics to Focus On: C++, Data Structures (especially trees and graphs), Dynamic Programming, Algorithms, Operating Systems, OOPS, DBMS, and Computer Networks.
  • Practice: Solve at least 5-6 coding questions daily on platforms like LeetCode and GeeksForGeeks. Analyze time and space complexity for each solution.
  • Resources: GeeksForGeeks articles and Coding Ninja’s Data Structures and Algorithms course in C++ were helpful.

Conclusion:
The candidate emphasized the importance of confidence in data structures and algorithms, along with a strong grasp of core computer science concepts. They advised against overloading resumes with unverified skills or projects and highlighted the value of one well-executed project. The overall experience was positive, and the candidate successfully secured the internship.

Useful Resources:

  • Amazon Software Developer Intern Fresher Interview Questions
75

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:
      1. Search in a row-wise and column-wise sorted matrix: Given an N x N matrix sorted in increasing order, find the position of a target integer ‘X’.
      2. Clone Linked List with Random Pointer: Given a linked list with two pointers in each node (one pointing to the next node and the other random), clone the list.
    • Your Approach:
      • For the matrix problem, I used a binary search approach to efficiently locate the target.
      • For the linked list problem, I implemented a hash map to map original nodes to their clones and handled the random pointers accordingly.
    • Outcome: Cleared the round with successful submissions.

  • Round 2 - Video Call (Technical):

    • Questions Asked:
      1. Row Wave Form: Given a 2D array, read elements row-wise and return a linear array in a wave-like pattern.
      2. Construct a strict binary tree: Given a preorder traversal array of a strict binary tree, construct the tree.
    • Your Approach:
      • For the wave form problem, I iterated through the matrix while alternating the direction of traversal for each row.
      • For the binary tree problem, I used recursion to build the tree from the preorder array, ensuring strict binary properties.
    • Outcome: Performed well and advanced to the next round.

  • Round 3 - Video Call (Technical):

    • Questions Asked:
      1. Alien Dictionary: Given a sorted dictionary of an alien language, determine the order of characters.
    • Your Approach:
      • I modeled the problem as a graph and used topological sorting to derive the character order.
    • Outcome: Successfully solved the problem and was selected for the internship.

Preparation Tips:

  • Topics to Focus On: Data Structures, Algorithms, OOPS, DBMS, OS, and Networks.
  • Time Required: 4 months of dedicated preparation.
  • Additional Tips:
    • Practice coding problems regularly.
    • Be confident and articulate your thought process clearly during interviews.
    • Mention only what you know on your resume, and competitive programming ranks can be a plus.

Conclusion:
Overall, the interview experience was challenging but rewarding. The key to success was thorough preparation and confidence during the interviews. I would advise future candidates to focus on problem-solving skills and clarity of thought. Good luck!

76

Company Name: Amazon

Position: Software Developer Intern

Location: Hyderabad

Application Process: Applied through the company’s career portal.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Dice Throws: Given D dice, each with F faces, find the number of ways to roll the dice to sum up to a target S.
      2. Count Set Bits: Calculate the total number of '1’s in the binary representation of numbers from 1 to N.
    • Your Approach: For the dice problem, I used dynamic programming to count the ways. For the set bits problem, I iterated through each number and counted the bits.
    • Outcome: Passed the round.

  • Round 2 - Face to Face (Technical):

    • Questions Asked:
      1. Postorder Traversal: Implement postorder traversal for a binary tree.
      2. Longest Increasing Subsequence: Find the length of the longest increasing subsequence in an array.
    • Your Approach: For the traversal, I used recursion. For the subsequence problem, I implemented the dynamic programming approach.
    • Outcome: Advanced to the next round.

  • Round 3 - Face to Face (Technical):

    • Questions Asked:
      1. Sort an Array in Wave Form: Rearrange the array to resemble a wave.
      2. System Design: Design a feature to show the last three watched movies on Amazon Prime.
      3. Data Structure: Implement a data structure supporting insert, delete, and getRandom operations.
    • Your Approach: For the wave array, I sorted and swapped elements. For the system design, I discussed a queue-based approach. For the data structure, I used a combination of a hash map and an array.
    • Outcome: Selected for the internship.

Preparation Tips:

  • Practice Amazon-tagged questions on platforms like GeeksforGeeks.
  • Focus on data structures (Binary Trees, Arrays, LinkedList, Graph, Stack, Queue) and algorithms.
  • Review system design basics, especially for features like tracking recent activities.

Conclusion:
The interview process was challenging but rewarding. I focused on understanding the problems thoroughly and communicating my thought process clearly. Practicing dynamic programming and system design questions was particularly helpful. For future candidates, I recommend solving as many problems as possible and being confident in your approach.

77

Company Name: Amazon

Position: Software Developer Intern

Location: Bangalore

Application Process: Applied through campus placement. The eligibility criteria included a CGPA > 6 and being from a non-Mechanical/Electrical Engineering background.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Remainder When Divided By 11: Given a very large number N as a string, find the remainder when N is divided by 11.
      2. Missing Number: Given an array of distinct binary strings representing integers from 0 to N, find the missing integer.
    • Your Approach: For the first question, I used modular arithmetic properties to avoid dealing with the large number directly. For the second question, I converted binary strings to integers and checked for the missing number in the sequence.
    • Outcome: Passed the round.

  • Round 2 - Face to Face Interview (SDE II):

    • Questions Asked:
      1. Fish Eater: Given an array representing fishes in a river, determine the number of fishes that can be eaten based on certain conditions.
      2. Fishmonger: A problem involving traversing through states with tolls and finding the optimal path for a fishmonger.
    • Your Approach: For the first question, I used a greedy approach to simulate the fish-eating scenario. For the second, I applied dynamic programming to minimize toll costs.
    • Outcome: Advanced to the next round.

  • Round 3 - Face to Face Interview (SDE III):

    • Questions Asked:
      1. Battalions and Tanks: Given battalions of soldiers and tanks, determine the optimal distribution.
      2. Diagonal Traversal of a Binary Tree: Perform a diagonal traversal of a given binary tree.
    • Your Approach: For the first question, I used a sorting and greedy strategy. For the second, I implemented a level-order traversal with a twist to handle diagonals.
    • Outcome: Selected for the internship.

Preparation Tips:

  • Focus on understanding the core concepts of algorithms and data structures rather than memorizing solutions.
  • Practice coding on any platform you prefer, but ensure you complete at least one thoroughly.
  • Be confident about everything on your resume, and keep it concise (1 page).

Conclusion:
Overall, the interview process was challenging but fair. The interviewers were friendly and focused on problem-solving approaches. I could have practiced more dynamic programming problems beforehand. My advice to future candidates is to stay calm, think aloud, and communicate your thought process clearly during interviews.

78

Company Name: Amazon

Position: Software Developer Intern

Location: Bangalore

Application Process: Applied through campus placement with eligibility criteria of above 6.5 CGPA and no backlogs.

Interview Rounds:

  • Round 1 - Coding Test:

  • Questions Asked:

    • Count inversions in an array.
    • Find pair with maximum GCD in an array.

  • Your Approach:

    • For the inversion count, I used a modified merge sort approach to efficiently count inversions.
    • For the GCD problem, I iterated through the array to find pairs and calculated their GCD, keeping track of the maximum.

  • Outcome: Cleared the round with both questions solved.

  • Round 2 - Video Call (Technical):

  • Questions Asked:

    • Array Queries: Given an array of size n (initially all 0s), perform q queries to update ranges and answer queries about the array.
    • Majority element in an array.
    • Subarray with equal occurrences of 0s and 1s.

  • Your Approach:

    • For the array queries, I used a prefix sum approach to handle range updates efficiently.
    • For the majority element, I implemented the Boyer-Moore voting algorithm.
    • For the subarray problem, I used a hashmap to track the balance of 0s and 1s.

  • Outcome: The interviewer was supportive, and I managed to solve all three problems.

  • Round 3 - Video Call (Technical):

  • Questions Asked:

    • Convert a sorted linked list to a balanced BST.
    • Implement a stack using a linked list.

  • Your Approach:

    • For the linked list to BST problem, I used a recursive approach to find the middle element and build the tree.
    • For the stack implementation, I used a singly linked list with push and pop operations at the head.

  • Outcome: The interviewer was satisfied with my solutions, and I cleared this round as well.

Preparation Tips:

  • Topics to Focus On: Data Structures and Algorithms, OOPS, DBMS, Computer Networks, Operating System.
  • Time Required: 4 months of consistent preparation.
  • Tips:
    • Practice a variety of questions rather than sticking to one type.
    • Be thorough with your projects and resume details, as they are discussed in detail.

Conclusion:
Overall, the interview experience was positive. The interviewers were supportive, and the questions were challenging but manageable with good preparation. My advice to future candidates is to stay consistent with practice and ensure clarity in whatever you mention in your resume. I was selected for the role, and I attribute my success to thorough preparation and confidence during the interviews.

79

Company Name: Amazon

Position: Software Developer Intern

Location: Bangalore

Application Process: Applied through campus placement at TIET - Thapar Institute of Engineering And Technology. The eligibility criteria included a CGPA above 7.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Max GCD Pair: Given an array of positive integers, find the maximum GCD among all possible pairs.
      2. Kevin and his Fruits: Kevin wants to eat at least ‘M’ fruits from ‘N’ buckets, and he sets a marker to achieve this.
    • Your Approach: Solved both questions efficiently, passing all test cases. For the Max GCD Pair, I iterated through the array to find the pair with the highest GCD. For Kevin’s problem, I used a binary search approach to determine the optimal marker.
    • Outcome: Cleared the round with all test cases passed.

  • Round 2 - Video Call (Technical):

    • Questions Asked:
      1. Bracket Number: Given a string with brackets, print the number of every bracket.
      2. Least Common Ancestor: Find the least common ancestor of two nodes in a binary tree.
      3. Operating System Concepts: Threading, Process, Semaphore, Deadlock, implementation of hashmap, time complexity.
    • Your Approach: For the bracket problem, I used a stack to keep track of the brackets. For the LCA problem, I implemented a recursive solution. For OS concepts, I explained each topic clearly with examples.
    • Outcome: Performed well and advanced to the next round.

  • Round 3 - Video Call (Technical):

    • Questions Asked:
      1. Running Median: Given a stream of integers, print the median after each addition.
      2. Detect Cycle in a Directed Graph: Check if a directed graph contains a cycle.
    • Your Approach: For the running median, I used two heaps (min and max) to efficiently compute the median. For the cycle detection, I implemented a DFS-based approach with a visited stack.
    • Outcome: Successfully cleared the round and received the internship offer.

Preparation Tips:

  • Topics to Focus On: Data structures, algorithms, OOPS, operating systems, and DBMS.
  • Time Required: 1 month of dedicated preparation.
  • Practice: Solve DSA questions regularly and ensure a strong grasp of fundamental concepts.
  • Resume Tips: Keep it concise (one page), include relevant links (GitHub, LinkedIn), and avoid unnecessary details.

Conclusion:
Overall, the interview experience was challenging but rewarding. The key to success was thorough preparation in DSA and OS concepts. I would advise future candidates to focus on problem-solving skills and clarity in explaining their approach. Regular practice and a well-structured resume can significantly boost your chances of success.

80

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:

    1. Longest Increasing Subsequence: Find the length of the longest subsequence in strictly increasing order.
    2. Count Inversions: Calculate the total number of inversions in an array.

  • Your Approach: Used dynamic programming for the first question and a modified merge sort approach for the second.

  • Outcome: Cleared the round.

  • Round 2 - Video Call (Technical):

  • Questions Asked:

    1. Anagram Pairs: Check if any permutation of a string is a palindrome.
    2. Longest Increasing Subsequence (again): Same as Round 1.
    3. Missing Number in a String: Find the missing number in a sequence of integers concatenated as a string.

  • Your Approach: Used frequency counting for the anagram question, dynamic programming for LIS, and iterative checking for the missing number.

  • Outcome: Cleared the round.

  • Round 3 - Video Call (Technical):

  • Questions Asked:

    1. Number of Islands: Count the number of islands in a 2D matrix.

  • Your Approach: Used Depth-First Search (DFS) to traverse and count islands.

  • Outcome: Rejected.

Preparation Tips:

  • Focus on Data Structures and Algorithms, especially dynamic programming and graph traversal.
  • Practice coding problems on platforms like LeetCode and GeeksforGeeks.
  • Be confident and articulate your thought process clearly during interviews.
  • Maintain at least 2 projects in your resume to showcase practical skills.

Conclusion:
Overall, the interview process was rigorous but fair. The interviewers were friendly and helpful when I got stuck. I could have practiced more graph problems and improved my problem-solving speed. For future candidates, focus on understanding core concepts and stay calm during interviews.