Amazon Software Developer Intern Interview Questions & Experience Guide

Interview Preparation
,
1

Amazon Software Developer Intern Interview Questions & Experience Guide

2

Company Name: Amazon

Position: Software Developer Intern

Location: BITS Pilani (Campus Placement)

Application Process: Applied through campus placement at Birla Institute of Technology and Science (BITS), Pilani. The interview took place before August 2023.

Interview Rounds:

  • Round 1 - Coding Test:
    • Questions Asked:
      • Searching in a sorted rotated array.
      • Invert a binary tree.
    • Your Approach: Focused on solving the problems efficiently using data structures and algorithms. For the sorted rotated array, I used binary search with modifications. For the binary tree inversion, I implemented a recursive approach.
    • Outcome: Cleared the round successfully.

Preparation Tips:

  • Practice data structures and algorithms thoroughly.
  • Focus on problem-solving techniques and time complexity optimization.

Conclusion:
The interview experience was smooth, and the questions were aligned with typical coding challenges. Practicing DS & Algo beforehand was crucial. For future candidates, I’d recommend consistent practice and understanding core concepts deeply.

3

Company Name: Amazon

Position: Software Developer Intern

Location: Indian School of Mines (ISM), Dhanbad

Application Process: Applied via campus placement at Indian School of Mines (ISM), Dhanbad before April 2023.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked: Very simple implementation questions.
    • Your Approach: Focused on writing clean and efficient code for the given problems.
    • Outcome: Passed the round.

  • Round 2 - Technical Round:

    • Questions Asked:
      • Q1. Number of connected components in a grid.
    • Your Approach: Used graph traversal techniques (DFS/BFS) to solve the problem.
    • Outcome: Successfully answered the question and moved forward in the process.

Preparation Tips:

  • Be thorough with graphs, trees, and arrays as these topics are frequently tested.

Conclusion:
The interview process was smooth, and the questions were aligned with standard DSA topics. Practicing graph-related problems beforehand helped a lot. For future candidates, I’d recommend focusing on core data structures and algorithms to ace the technical rounds.

4

Company Name: Amazon

Position: Software Developer Intern

Location: [Not specified]

Application Process: Applied via campus placement before March 2023.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked: 2 OA questions with difficulty similar to LeetCode medium-hard.
    • Your Approach: Focused on solving the problems efficiently, ensuring optimal time and space complexity.
    • Outcome: Passed the round.

  • Round 2 - Technical Round:

    • Questions Asked:
      1. Two data structures and algorithms questions.
      2. Longest substring without repeating characters.
    • Your Approach: For the first question, analyzed the problem and chose the appropriate data structures. For the second question, implemented a sliding window approach to solve it.
    • Outcome: Successfully answered the questions and advanced to the next stage.

Preparation Tips:

  • Practiced extensively on LeetCode, focusing on medium-hard problems.
  • Reviewed core data structures and algorithms concepts.
  • Simulated timed coding sessions to improve speed and accuracy.

Conclusion:
The interview process was challenging but well-structured. Preparing with consistent practice and understanding problem-solving techniques was key. For future candidates, I recommend focusing on problem-solving patterns and time management during coding rounds.

5

Company Name: Amazon

Position: Software Developer Intern

Location: Hyderabad

Application Process: Applied through the campus placement process at AKGEC (Ajay Kumar Garg Engineering College).

Interview Rounds:

  • Round 1 - Coding Test:

  • Questions Asked:

    • Q1. Two Sum: Given an array of integers and a target, return all pairs of elements that add up to the target. The problem required handling edge cases and optimizing for O(N) time complexity.

  • Your Approach: Used a hash map to store elements and their indices, iterating through the array to find complementary values.

  • Outcome: Cleared the round with all test cases passing.

  • Round 2 - Video Call (Technical Interview):

  • Questions Asked:

    • Q1. Rotting Oranges: Given a grid representing oranges (fresh, rotten, or empty), determine the minimum time required for all oranges to rot.

  • Your Approach: Used BFS to simulate the rotting process, tracking time and ensuring all oranges were accounted for.

  • Outcome: Successfully explained the approach and coded the solution. Cleared the round.

  • Round 3 - Video Call (Technical Interview):

  • Questions Asked:

    • Q1. Power Set: Given a sorted array, generate all possible subsets (power set).

  • Your Approach: Used backtracking to generate subsets, ensuring no duplicates and maintaining the sorted order.

  • Outcome: Provided a clear explanation and efficient solution. Cleared the round.

Preparation Tips:

  • Focus on Data Structures, Algorithms, and Competitive Programming.
  • Consistency and dedication are key—prepare for at least 8 months.
  • Ensure concepts are crystal clear before attempting problems.
  • Work on projects to showcase practical knowledge.
  • Only include what you know on your resume.

Conclusion:
Overall, the interview process was challenging but rewarding. The key to success was thorough preparation and clarity of concepts. For future candidates, I recommend practicing consistently and understanding the underlying logic of problems rather than memorizing solutions. Being confident and articulate during the interview also plays a crucial role.

6

Company Name: Amazon

Position: Software Developer Intern

Location: Not specified

Application Process: I applied via LinkedIn and was interviewed before September 2022.

Interview Rounds:

  • Round 1 - Resume Shortlist:

    • Questions Asked: None (Resume screening round).
    • Your Approach: Ensured my resume was crisp and highlighted relevant skills and projects.
    • Outcome: Passed to the next round.

  • Round 2 - Coding Test:

    • Questions Asked: 2 easy-level problems on HackerRank.
    • Your Approach: Solved the problems efficiently, focusing on correctness and optimality.
    • Outcome: Cleared the round.

  • Round 3 - Technical Interview:

    • Questions Asked:
      1. Easy standard problem on arrays.
      2. Medium standard problem on matrices.
    • Your Approach: Explained my thought process clearly, wrote clean code, and optimized solutions where possible.
    • Outcome: Awaiting results.

Preparation Tips:

  • Practice coding problems on platforms like HackerRank, LeetCode, and CodeChef.
  • Revise data structures and algorithms thoroughly.
  • Ensure your resume is concise and highlights relevant projects and skills.

Conclusion:
Overall, the interview process was smooth. I focused on clarity and efficiency in my responses. For future candidates, I’d recommend practicing standard problems and being confident in explaining your solutions.

7

Company Name: Amazon

Position: Software Developer Intern

Application Process: I applied through campus placements in January 2021. The process included two 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. Merge Two Sorted Linked Lists: Merge two sorted linked lists into one sorted linked list.
    • Your Approach: For the palindrome question, I used a two-pointer technique to compare the first half of the list with the reversed second half. For merging the sorted lists, I iterated through both lists, comparing nodes and merging them in ascending order.
    • Outcome: Passed this round and moved to the next stage.

  • Round 2 - Video Call Interview:

    • Questions Asked:
      1. Palindrome Partitioning: Partition a given string such that every substring is a palindrome.
      2. DBMS Question: Describe the ACID properties in DBMS.
    • Your Approach: For the palindrome partitioning, I used backtracking to explore all possible partitions and checked each substring for being a palindrome. For the DBMS question, I explained Atomicity, Consistency, Isolation, and Durability with examples.
    • Outcome: Successfully answered both questions and was selected for the internship.

Preparation Tips:

  • Topics to Focus On: Data Structures (especially trees and graphs), Algorithms, C++, Operating Systems, DBMS, and Computer Networks.
  • Time Management: Dedicate at least 4 months for thorough preparation.
  • Projects: Prepare 2-3 projects with in-depth understanding, as questions will likely revolve around them.
  • Optimization: Always consider time and space complexity while solving problems and aim for optimized solutions.
  • Resume: Keep it concise (1 page max) and include only projects and skills you are confident about.

Conclusion:
The interview process was well-structured and tested both coding and theoretical knowledge. Practicing problem-solving on platforms like LeetCode and understanding core CS concepts were key to my success. For future candidates, focus on clarity of thought, confidence in your answers, and thorough preparation of your resume and projects.

8

Company Name: Amazon

Position: Software Developer Intern

Location: (Not specified)

Application Process: I applied through the campus placement process at my university. The eligibility criteria included no backlogs and a minimum CGPA of 6.

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’ or return {-1, -1} if not found.
      2. Number of Pairs with Given Sum: Given an integer array and a sum value, find and return the total number of pairs in the array that sum up to the given value.
    • Your Approach: For the first question, I used a binary search approach to efficiently locate the target in the matrix. For the second question, I utilized a hash map to store elements and check for pairs, ensuring optimal time complexity.
    • Outcome: I successfully solved both questions within the time limit and advanced to the next round.

  • Round 2 - Video Call (Technical Interview):

    • Questions Asked:
      1. Fire in the cells: A matrix-based problem where certain cells represented fire, and the task was to determine the spread of fire over time.
      2. OS Questions:
        • What is thrashing?
        • Explain the Round Robin Scheduling algorithm.
    • Your Approach: For the matrix problem, I used a BFS approach to simulate the spread of fire. For the OS questions, I provided clear definitions and examples to explain the concepts.
    • Outcome: The interviewer seemed satisfied with my solutions and explanations, and I was selected for the internship.

Preparation Tips:

  • Topics to Focus On: C++, Algorithms, Operating Systems, Object-Oriented Programming, Database Management Systems, Computer Networks, and Data Structures (especially trees and graphs).
  • Practice: Solve at least 200 DSA problems and understand algorithms thoroughly.
  • Projects: Develop 2-3 projects and ensure you have in-depth knowledge of them.
  • Aptitude: Practice aptitude and reasoning questions.

Conclusion:
Overall, the interview process was challenging but rewarding. I felt well-prepared due to my consistent practice and project work. My advice to future candidates is to focus on understanding core concepts thoroughly and to practice problem-solving regularly. Confidence and clarity in communication are also key during interviews.

9

Company Name: Amazon

Position: Software Developer Intern

Location: Not specified

Application Process: The interview was conducted in January 2021. The process included a coding test followed by a video call round.

Interview Rounds:

  • Round 1 - Coding Test Round:

    • Questions Asked:
      1. Add Linked Lists: Given two numbers represented by linked lists, the task was to find the sum list and return the head of the sum list.
      2. Check if Linked List is Palindrome: Determine if the given linked list is a palindrome.
    • Your Approach: For the first question, I iterated through both linked lists, added the corresponding digits, and handled carry-over. For the second question, I used a two-pointer technique to compare the first half of the list with the reversed second half.
    • Outcome: Passed this round.

  • Round 2 - Video Call Round:

    • Questions Asked:
      1. Square Root (Decimal): Find the square root of a number with precision up to a given number of decimal places.
      2. Alien Dictionary: Given a sorted dictionary of an alien language, determine the order of characters.
    • Your Approach: For the square root question, I implemented the binary search approach to find the root. For the alien dictionary, I used topological sorting to determine the character order.
    • Outcome: Selected for the internship.

Preparation Tips:

  • Topics to Prepare: Algorithms, Data Structures, C++, Java, OOPS, DBMS, Operating Systems, Computer Networks.
  • Time Required: 4 months of dedicated preparation.
  • Tip 1: Focus on mastering Data Structures and Algorithms as they are fundamental.
  • Tip 2: Revise Object-Oriented Programming thoroughly.
  • Tip 3: Practice at least 200 DSA problems and aptitude questions regularly.

Application Resume Tips:

  • Keep the resume concise (1 page max).
  • Highlight skills, projects, and achievements you have in-depth knowledge of.
  • Include links to LinkedIn, GitHub, or personal websites.

Conclusion:
The interview process was challenging but fair. Practicing DSA problems and understanding core concepts helped me perform well. For future candidates, I recommend consistent practice and focusing on problem-solving techniques.

Final Outcome: Selected for the internship.

10

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 required candidates to be 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.
      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 bitwise operations to find the rightmost set bit. For the second question, I applied dynamic programming to solve the problem efficiently.
    • Outcome: Passed this round.

  • Round 2 - Telephonic Call (Technical):

    • 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 classic puzzle involving transporting bananas with a camel.
    • Your Approach: For the first question, I used memoization to optimize the recursive solution. For the puzzle, I broke it down into smaller subproblems to find the optimal solution.
    • Outcome: Cleared this round successfully.

  • Round 3 - HR Round:

    • Questions Asked:
      1. Basic HR questions like willingness to relocate, knowledge about Amazon, and long-term career goals.
    • Your Approach: I answered honestly and confidently, showcasing my enthusiasm for the role and company.
    • Outcome: Selected for the internship.

Preparation Tips:

  • Focus on Data Structures, Trees, Graphs, Arrays, Backtracking, Pointers, OOPS, System Design, Greedy Algorithms, and Dynamic Programming.
  • Solve all the must-do questions available on GeeksforGeeks.
  • Practice regularly on platforms like Codechef and Codeforces to build a strong profile.
  • Team projects can give you an edge over others.
  • For freshers, a placement preparation course can be very helpful in a short span of time.

Conclusion:
Overall, the interview experience was challenging but rewarding. The key to success was consistent practice and a clear understanding of core concepts. I would advise future candidates to focus on problem-solving and to be confident during the HR round. Having a well-prepared resume with links to competitive profiles can also make a strong impression.

11

Company Name: Amazon

Position: Software Developer Intern

Location: Hyderabad

Application Process: Applied through the campus placement process for 2021 graduates.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Search In A Row Wise And Column Wise Sorted Matrix
      2. Subtree of Another Tree
    • Your Approach:
      • For the first question, I used a binary search approach to efficiently locate the target element in the sorted matrix.
      • For the second question, I implemented a recursive solution to check if one tree is a subtree of another by comparing nodes and structures.
    • Outcome: Cleared the round with both questions solved correctly.

  • Round 2 - Video Call (Technical Interview):

    • Questions Asked:
      1. N Queens Problem
      2. Time To Burn Tree
    • Your Approach:
      • For the N Queens problem, I used backtracking to place queens on the chessboard such that no two queens threaten each other.
      • For the Time To Burn Tree question, I employed a BFS approach to simulate the burning process and calculate the time required.
    • Outcome: Successfully solved both problems and advanced to the next round.

  • Round 3 - Video Call (Technical Interview):

    • Questions Asked:
      1. Bottom View Of Binary Tree
    • Your Approach:
      • I used a level-order traversal (BFS) with a hash map to track the horizontal distance of nodes and ensure the bottom view was captured correctly.
    • Outcome: Solved the problem efficiently and received positive feedback.

Preparation Tips:

  • Focus on mastering Data Structures and Algorithms, especially trees, graphs, and backtracking.
  • Practice coding under time constraints to improve speed and accuracy.
  • Mock interviews can significantly enhance communication and problem-solving skills.

Conclusion:
Overall, the interview process was rigorous but well-structured. The key to success was thorough preparation and staying calm under pressure. I would advise future candidates to practice extensively on platforms like LeetCode and GeeksforGeeks and to ensure their fundamentals are strong. The interviewers were supportive, and the experience was enriching.

12

Company Name: Amazon

Position: Software Developer Intern

Location: [Not specified]

Application Process: [Not specified]

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Merge Two Sorted Linked Lists
      2. Rat In A Maze
      3. Two Sum
    • Your Approach:
      • For the first question, I used a two-pointer approach to merge the linked lists efficiently.
      • For the second question, I implemented a backtracking algorithm to find the path for the rat in the maze.
      • For the third question, I used a hash map to store elements and their indices to find pairs that sum up to the target.
    • Outcome: Passed this round.

  • Round 2 - Video Call (Technical):

    • Questions Asked:
      1. Longest Increasing Subsequence
      2. Boundary Traversal of a Binary Tree
      3. Spiral Matrix
    • Your Approach:
      • For the first question, I used dynamic programming to find the longest increasing subsequence.
      • For the second question, I broke it down into three parts: left boundary, leaves, and right boundary.
      • For the third question, I used a layer-by-layer approach to traverse the matrix in a spiral order.
    • Outcome: Passed this round.

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

    • Questions Asked:
      1. OS Questions (Threads vs Process, What is an operating system, Memory Management)
      2. DBMS Questions (Normal forms, SQL queries)
    • Your Approach:
      • I answered the OS questions by explaining the differences and concepts clearly.
      • For DBMS, I discussed normalization and wrote a few SQL queries.
    • Outcome: Selected for the internship.

Preparation Tips:

  • Topics to prepare: Data Structures and Algorithms, OS, DBMS, CN, OOPs Concepts.
  • Time required: 3 months.
  • Tip 1: Keep your resume concise and single-page.
  • Tip 2: Stay calm and confident during the interview.
  • Tip 3: Practice previous interview questions from Amazon.

Conclusion:
Overall, the interview process was smooth, and the questions were aligned with my preparation. I focused on understanding core concepts and practicing coding problems, which helped me perform well. For future candidates, I recommend thorough preparation and confidence in your answers.

13

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 having a CGPA above 7.

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 compute the maximal AND value and count the subsequences. I used bit manipulation techniques to optimize the solution.
    • Outcome: The round was of medium difficulty, and I was able to solve the problem within the given time.

  • 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. I provided examples of how they work in multi-threaded environments.
    • Outcome: The round was easy, and my explanation was clear.

  • 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 computer. I explained its benefits, such as allowing larger programs to run and enabling memory isolation.
    • Outcome: The round was easy, and I answered confidently.

Preparation Tips:

  • Topics to Prepare: Data Structures, Pointers, OOPS, System Design.
  • Time Required: 3 months.
  • Tip 1: Practice at least 250 coding questions.
  • Tip 2: Work on at least 2 projects to showcase practical skills.
  • Resume Tip 1: Include projects on your resume.
  • Resume Tip 2: Avoid false information on your resume.

Conclusion:
Overall, the interview experience was challenging but rewarding. The coding rounds tested my problem-solving skills, while the OS questions evaluated my conceptual understanding. Although I was rejected, I learned a lot and would advise future candidates to focus on strong fundamentals and practical projects.

14

Company Name: Amazon

Position: Software Developer Intern

Location: Not specified

Application Process: Applied through campus placement at National Institute of Technology, Kurukshetra.

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. 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: For the palindrome question, I used a two-pointer technique to compare the first half of the list with the reversed second half. For the matrix paths problem, I implemented dynamic programming to count the paths efficiently.
    • Outcome: Passed the round.

  • Round 2 - Video Call (Technical Interview):

    • Questions Asked:
      1. Square Root (Decimal): Implement a function to find the square root of a number with precision up to D decimal places.
      2. DBMS Question: Explain ACID properties in database systems.
    • Your Approach: For the square root problem, I used the binary search approach to narrow down the solution. For the ACID properties, I explained each property (Atomicity, Consistency, Isolation, Durability) with examples.
    • Outcome: Selected for the internship.

Preparation Tips:

  • Focus on Data Structures and Algorithms, especially linked lists, dynamic programming, and binary search.
  • Prepare at least 2-3 projects thoroughly, ensuring you can explain the logic and implementation.
  • Practice reasoning and aptitude questions alongside coding problems.
  • Keep an eye on time and space complexity while solving problems.

Conclusion:
The interview process was well-structured, and the questions were aligned with my preparation. I could have practiced more dynamic programming problems to feel more confident. My advice to future candidates is to focus on core concepts and practice consistently. Also, ensure your resume is concise and highlights only relevant skills and projects.

15

Company Name: Amazon

Position: Software Developer Intern

Location: Bangalore

Application Process: Applied through campus placement with eligibility criteria of above 7.5 CGPA for B.Tech students.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. First negative integer in every window of size “k”
      2. Maximum Sum of nodes in a binary tree such that no two nodes are adjacent
    • Your Approach: For the first question, I used a sliding window approach to efficiently find the first negative integer in each window. For the second question, I applied dynamic programming to ensure no two adjacent nodes were selected while maximizing the sum.
    • Outcome: Passed this round.

  • Round 2 - Video Call (Technical Interview):

    • Questions Asked:
      1. Validate BST (Binary Search Tree)
      2. Basic Aptitude Questions (mislabeled jars problem)
    • Your Approach: For the BST question, I checked the inorder traversal to ensure it was sorted. For the aptitude question, I used logical reasoning to determine the correct labeling of the jars.
    • Outcome: The interview lasted 90 minutes, and the environment was user-friendly. However, I was rejected after this round.

Preparation Tips:

  • Focus on DSA topics like pointers, arrays, linked lists, graphs, trees, constructive algorithms, dynamic programming, and brute force approaches.
  • Practice questions from platforms like InterviewBit.
  • Work on at least 3 projects, with one major project (preferably in web development).
  • Improve communication skills for better interaction during interviews.

Conclusion:
Overall, the experience was insightful. I realized the importance of thorough preparation, especially in problem-solving and communication. For future candidates, I recommend practicing extensively and ensuring clarity in explaining solutions during interviews.

16

Company Name: Amazon

Position: Software Developer Intern

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

Interview Rounds:

  • Round 1 - Aptitude Test:
    • Questions Asked: The test included questions on CS fundamentals, Linux, and one DSA problem.
    • Your Approach: Focused on revising core CS concepts and practicing basic Linux commands beforehand. For the DSA problem, I took a systematic approach to break it down into smaller parts.
    • Outcome: Cleared the round successfully. The questions were straightforward, and preparation paid off.

Preparation Tips:

  • Brush up on CS fundamentals like OS, DBMS, and networking.
  • Practice basic Linux commands as they are often tested.
  • Solve DSA problems from platforms like LeetCode or GeeksforGeeks to build confidence.

Conclusion:
The overall experience was smooth, and the questions were aligned with what I had prepared. I would advise future candidates to focus on core CS topics and practice problem-solving regularly.

17

Company Name: Amazon

Position: Software Developer Intern

Location: Bengaluru

Application Process: I applied for the job as 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 a sorted N x N matrix, find if a target value exists.
    • Your Approach: For the first question, I used a BFS approach to traverse connected 1s. For the second question, I leveraged the sorted property to implement an efficient search.
    • Outcome: Passed this round.

  • Round 2 - Video Call (Technical Interview):

    • 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 problem, I used a two-pointer technique. For the pair sum, I optimized using a hash map.
    • Outcome: Advanced to the next round.

  • Round 3 - Video Call (Technical Interview):

    • Questions Asked:
      1. Rat in a Maze: Given a maze, find all paths a rat can take from the start to the end, moving only right or down.
    • Your Approach: I used backtracking to explore all possible paths.
    • Outcome: This was a pure DSA round, and I performed well enough to be selected.

Preparation Tips:

  • Topics to Focus On: Data Structures (especially Trees and Graphs), Arrays, Backtracking, Pointers, OOPS, System Design, Greedy Algorithms, Dynamic Programming.
  • Time Required: 6 months of consistent practice.
  • Tips:
    1. Practice as many problems as you can.
    2. Code under time constraints to simulate real interview conditions.
    3. Consistency is key—keep practicing daily.

Conclusion:
Overall, the interview process was challenging but fair. I felt well-prepared due to my consistent practice. If I could do anything differently, I would focus more on optimizing my solutions further. My advice to future candidates is to start early, practice regularly, and stay calm during interviews.

Final Outcome: Selected!

18

Company Name: Amazon

Position: Software Developer Intern

Location: [Not specified]

Application Process: [Not specified]

Interview Rounds:

  • Round 1 - Video Call (Technical Interview):

  • Questions Asked:

    • Reverse Linked List: You are given a Singly Linked List of integers. You need to reverse the Linked List by changing the links between nodes.
    • The Celebrity Problem: There are ‘N’ people at a party. Each person has been assigned a unique id between 0 to ‘N’ - 1(both inclusive). A celebrity is a person who is known to everyone but doesn’t know anyone.

  • Your Approach:

    • For the Linked List problem, I used the iterative method to reverse the list by changing the pointers.
    • For the Celebrity Problem, I used a stack-based approach to identify the celebrity by eliminating non-celebrity candidates.

  • Outcome: Passed the round and moved forward in the process.

Preparation Tips:

  • Focus on Data Structures and Algorithms, especially Graphs and Dynamic Programming.
  • Practice coding problems thoroughly and understand the underlying concepts.
  • Prepare for Object-Oriented Programming (OOPS) concepts as well.
  • Spend at least 7 months preparing for the interview.

Conclusion:

The interview experience was positive, and the environment was supportive. The questions were medium difficulty, and my preparation in DSA helped me perform well. For future candidates, I recommend practicing coding problems regularly and building a strong foundation in problem-solving. Confidence and clarity in explaining your approach are key.

Final Outcome: Selected

19

Company Name: Amazon

Position: Software Developer Intern

Location: Hyderabad

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

Interview Rounds:

  • Round 1 - Video Call Round (60 minutes):

    • Questions Asked:

      1. Spiral Order Traversal of a Binary Tree: Given a binary tree, print its nodes in spiral order traversal.
      2. Row Of A Matrix With Maximum Ones: Given a 2D matrix with sorted rows (containing '0’s and '1’s), find the row with the maximum number of '1’s.

    • Your Approach:

      • For the binary tree problem, I used a combination of BFS and a flag to alternate the direction of traversal.
      • For the matrix problem, I leveraged the sorted property of rows to count the number of '1’s efficiently using binary search.

    • Outcome: I passed this round and was invited for the next round.

  • Round 2 - Video Call Round (70 minutes):

    • Questions Asked:

      1. Sort An Array According To The Count Of Set Bits: Given an array of integers, sort it based on the count of set bits in their binary representation.
      2. Rotting Oranges: Given a grid representing oranges (fresh or 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.
      • For the rotting oranges problem, I applied BFS to simulate the rotting process and calculated the time required.

    • Outcome: I performed well in this round and was selected for the internship.

Preparation Tips:

  • Topics to Focus On: Dynamic Programming, Stacks, Array Manipulation, Linked Lists, Binary Trees, Divide and Conquer.
  • Time Required: Dedicate at least 2 months for thorough preparation.
  • Additional Tips:
    • Master basic Data Structures and Algorithms (DSA) with their time and space complexities.
    • Practice competitive programming to improve problem-solving speed.
    • Work on projects and be prepared to discuss them in detail.

Conclusion:

The interviewers were friendly and made the process comfortable. I felt well-prepared due to my focus on DSA and competitive programming. If I could improve anything, I would practice more mock interviews to refine my communication. For future candidates, honesty in your resume and clarity in problem-solving are key. Best of luck!

20

Company Name: Amazon

Position: Software Developer Intern

Location: Not specified

Application Process: Applied through campus placement.

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 a 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 track complements for efficient lookup.
    • Outcome: Passed both questions and advanced to the next round.

  • Round 2 - Video Call (Technical 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 method 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 received positive feedback.

Preparation Tips:

  • Focus on mastering Data Structures and Algorithms, especially trees and graphs.
  • Practice coding questions regularly (5-6 daily) on platforms like LeetCode and GeeksforGeeks.
  • Analyze time and space complexity for each solution and work on optimization.
  • Study core concepts of Operating Systems, Databases, and Object-Oriented Programming in detail.
  • Refer to resources like GeeksforGeeks for theoretical knowledge.

Conclusion:
The interview process was challenging but rewarding. I felt well-prepared due to consistent practice and thorough understanding of key concepts. My advice to future candidates is to focus on problem-solving strategies and clarity of thought during interviews. Also, ensure your resume highlights only those skills and projects you can confidently discuss.