Amazon Software Develper Intern Interview Questions & Experience Guide

Interview Preparation
,
1

Amazon Software Develper Intern Interview Questions & Experience Guide

2

Company Name: Amazon

Position: Software Developer Intern

Application Process: Applied via the company website and was interviewed before March 2023.

Interview Rounds:

  • Round 1 - Coding Test:
  • Questions Asked: The test included 2 coding questions.
  • Your Approach: Focused on solving the problems using strong knowledge of Data Structures and Algorithms (DSA). The key areas tested were Graphs, Trees, and Dynamic Programming.
  • Outcome: Successfully cleared the round by solving both questions.

Preparation Tips:

  • Topics to prepare: Graphs, Trees, Dynamic Programming, and other core DSA concepts.
  • Practice coding problems regularly to improve problem-solving speed and accuracy.

Conclusion:
The interview process was smooth, and having a solid grasp of DSA was crucial. I recommend practicing extensively on these topics to ace the coding test. Good luck to future candidates!

3

Company Name: Amazon

Position: Software Developer Intern

Location: Not specified

Application Process: Applied through campus placement or online application (not explicitly mentioned).

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Subtree of Another Tree
      2. Clone Linked List with Random Pointer
    • Your Approach: Focused on solving the problems efficiently using tree traversal and linked list manipulation techniques.
    • Outcome: Passed the round.

  • Round 2 - Video Call (Technical Interview):

    • Questions Asked:
      1. Flip Bit to Win
      2. Saving Money (Graph-based problem)
    • Your Approach: Used dynamic programming for the first question and graph traversal for the second.
    • Outcome: Advanced to the next round.

  • Round 3 - Video Call (Technical Interview):

    • Questions Asked:
      1. Row with Maximum 1’s
      2. Knight Probability in Chessboard
    • Your Approach: Solved the first problem using binary search and the second using dynamic programming.
    • Outcome: Selected for the internship.

Preparation Tips:

  • Covered common topics like Linked List, Binary Search, Dynamic Programming, Two-pointer, Hashmap, Heap, OOPS, Stack, and Queues.
  • Solved at least 300+ common coding problems.
  • Reviewed interview experiences of the company.
  • Practiced mock interviews.

Conclusion:
The interview process was challenging but rewarding. The key to success was thorough preparation and practicing a variety of problems. Mock interviews helped build confidence. For future candidates, focus on problem-solving and understanding core concepts deeply.

4

Company Name: Amazon

Position: Software Developer Intern

Location: Not specified

Application Process: The interview was conducted in November 2020. The process included a coding test followed by two video call rounds.

Interview Rounds:

  • Round 1 - Coding Test Round:

    • 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 matrix.
      • For the second question, I implemented a recursive solution to check if one tree is a subtree of another.
    • Outcome: Cleared the round.

  • Round 2 - Video Call Round:

    • Questions Asked:
      1. Reachable Nodes in a graph.
      2. Squares of a Sorted Array.
    • Your Approach:
      • For the first question, I used a BFS traversal to count reachable nodes from a given node.
      • For the second question, I squared each element and then sorted the resulting array.
    • Outcome: Cleared the round.

  • Round 3 - Video Call Round:

    • Questions Asked:
      1. Valid String with parentheses and asterisks.
      2. Convert a binary tree to its sum tree.
    • Your Approach:
      • For the first question, I used a greedy approach to validate the string.
      • For the second question, I recursively updated each node’s value to the sum of its subtrees.
    • Outcome: Cleared the round and got selected.

Preparation Tips:

  • Focus on Data Structures and Algorithms, especially Arrays, Binary Search, Trees, Graphs, and Dynamic Programming.
  • Practice coding on platforms like LeetCode, GFG, and InterviewBit.
  • Take mock interviews to build confidence and improve problem-solving speed.

Conclusion:
The interview process was challenging but well-structured. The interviewers were supportive and provided a comfortable environment. Practicing company-specific questions and mock interviews helped me perform well. My advice to future candidates is to focus on problem-solving skills and clarity of thought during interviews.

5

Company Name: Amazon

Position: Software Developer Intern

Location: Hyderabad

Application Process: I applied through the campus placement process at my college. The eligibility criteria included a minimum CGPA of 7.5.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Flatten BST To A Sorted List: Given a BST, the task was to flatten it into a sorted list (right-skewed BST).
      2. Prerequisite Task: Given tasks with dependencies, determine if all tasks can be completed.
    • Your Approach: For the BST problem, I used an in-order traversal to collect nodes and then reconstructed the tree. For the prerequisite task, I modeled it as a graph and checked for cycles using topological sorting.
    • Outcome: Passed this round.

  • Round 2 - Video Call (Technical Interview):

    • Questions Asked:
      1. Sort Linked List: Given a linked list sorted by absolute values, sort it by actual values.
      2. Convert BST To Greater Sum Tree: Modify the BST such that each node’s value is replaced by the sum of all greater values.
    • Your Approach: For the linked list, I separated negative and positive nodes and merged them. For the BST problem, I used reverse in-order traversal to accumulate sums.
    • Outcome: Passed this round.

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

    • Questions Asked:
      1. Split the given array into K sub-arrays: Given an array and an integer K, split the array into K sub-arrays with minimal maximum sum.
    • Your Approach: I used binary search to find the minimal maximum sum by checking feasible splits.
    • Outcome: Unfortunately, I was rejected after this round.

Preparation Tips:

  • Focus on strengthening your understanding of Trees, Linked Lists, Graphs, Arrays, and Binary Search.
  • Start with easy-level problems, then move to medium and hard.
  • Consistency is key—stay focused and practice regularly.

Conclusion:
Overall, the interview experience was challenging but enriching. I realized the importance of time management and clarity in explaining my thought process. For future candidates, I recommend practicing problem-solving under time constraints and ensuring a strong grasp of fundamental data structures and algorithms.

6

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 7.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Sorted Subsequence of Size 3: Given an array, find a subsequence of three elements in strictly increasing order.
      2. Check if two trees are Mirror: Determine if two given binary trees are mirror images of each other.
    • Your Approach: For the first question, I used a two-pointer approach to find the subsequence efficiently. For the second question, I implemented a recursive solution to compare the left and right subtrees of the trees.
    • Outcome: I qualified for the next round.

  • Round 2 - Video Call Round:

    • Questions Asked:
      1. Convert BST to the Greater Sum Tree: Modify a BST such that each node’s value is replaced by the sum of all nodes greater than it.
      2. Game of 3: A puzzle involving integers and specific operations.
    • Your Approach: For the BST question, I performed a reverse in-order traversal to accumulate the sum. For the puzzle, I used a greedy approach to solve it step-by-step.
    • Outcome: The interviewer was supportive, but unfortunately, I was rejected after this round.

Preparation Tips:

  • Focus on topics like Recursion, Dynamic Programming, OOPS, System Design, and Trees.
  • Spend at least 6 months preparing thoroughly.
  • Work on at least 3 major web development projects to strengthen your practical skills.
  • Practice coding problems from platforms like Interview Bit.

Conclusion:
Overall, the interview experience was insightful. The interviewers were helpful, and the questions were challenging but fair. I could have prepared more thoroughly for system design and dynamic programming. My advice to future candidates is to focus on problem-solving and clarity of thought during interviews. Keep your resume concise and relevant.

7

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. Check whether the second string can be formed from the characters of the first string.
      2. Search in a row-wise and column-wise sorted matrix.
    • Your Approach: For the first question, I used a frequency map to count characters in both strings and compared them. For the second question, I implemented a binary search approach to efficiently locate the target element.
    • Outcome: Passed this round.

  • Round 2 - Video Call (Technical Round):

    • Questions Asked:
      1. Count distinct elements in every K-size window.
      2. Merge two sorted linked lists.
      3. Operating System questions:
        • What is thrashing?
        • Explain the Round Robin Scheduling algorithm.
    • Your Approach: For the first question, I used a sliding window technique with a hash map. For the second, I iterated through both lists and merged them in sorted order. For the OS questions, I explained thrashing as excessive paging and described Round Robin Scheduling with time slices.
    • Outcome: Selected for the internship.

Preparation Tips:

  • Practice at least 300 problems from platforms like LeetCode and GeeksforGeeks.
  • Focus on Data Structures (Linked Lists, Binary Trees, Graphs, etc.), Algorithms (Dynamic Programming, Heaps), and core subjects like Operating Systems.
  • Keep your resume concise, highlighting projects and relevant skills.

Conclusion:
The interview process was rigorous but fair. Practicing a variety of problems and understanding core concepts thoroughly helped me perform well. I recommend focusing on problem-solving skills and being clear with fundamentals. Good luck to future candidates!

8

Company Name: Amazon

Position: Software Developer Intern

Location: Hyderabad

Application Process:
I applied through my college’s campus placement process. The eligibility criteria included being from the CSE department with a CGPA above 6.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Subtree of Another Tree: Given two binary trees, check if one is a subtree of the other.
      2. Search In A Row Wise And Column Wise Sorted Matrix: Find a given element in a sorted matrix.
    • Your Approach:
      For the first question, I used a recursive approach to compare the trees. For the second, I utilized the sorted property of the matrix to optimize the search.
    • Outcome: Passed this round. The questions were relatively easy, and the workstyle assessment played a significant role in selection.

  • Round 2 - Video Call (Technical Interview 1):

    • Questions Asked:
      1. Maximum Of All Subarrays Of Size k: Find the maximum element in all contiguous subarrays of size k.
      2. Chocolate Problem: Distribute chocolates among students with constraints.
      3. First Repeated Character: Find the first repeating character in a string.
    • Your Approach:
      I coded solutions for the first two questions and provided an approach for the third. The interviewer was helpful and guided me when I got stuck.
    • Outcome: Passed this round. The interviewer appreciated my clean code and problem-solving approach.

  • Round 3 - Video Call (Technical Interview 2):

    • Questions Asked:
      1. Snake and Ladder: Simulate the game and find the minimum steps to reach the end.
    • Your Approach:
      I discussed my approach with the interviewer, who helped me refine it. The focus was on time and space complexities.
    • Outcome: Passed this round. The interviewer was satisfied with my solution and the discussion.

Preparation Tips:

  • Focus on data structures and algorithms, especially Dynamic Programming, Graphs, LinkedList, Trees, and Bit Manipulation.
  • Practice medium-level questions on platforms like LeetCode. Quality of practice matters more than quantity.
  • Understand Amazon’s 14 Leadership Principles and incorporate them into your answers during the workstyle assessment.

Conclusion:
Overall, the interview experience was positive. The interviewers were friendly and supportive. I could have prepared more for time and space complexities, but my problem-solving skills and clean coding helped me succeed. For future candidates, I recommend thorough preparation and practicing meaningful variable naming in your code.

9

Company Name: Amazon

Position: Software Developer Intern

Location: Bangalore

Application Process: Applied through the campus placement process at Malaviya National Institute of Technology Jaipur. Eligibility criteria included a CGPA above 7 and no backlogs.

Interview Rounds:

  • Round 1 - Coding Test:

  • Questions Asked:

    • Longest decreasing sub-sequence (Dynamic Programming problem).
    • Finding mean, median, and mode in an array.
    • 28 MCQs on Computer Science fundamentals.

  • Your Approach: Focused on solving the coding questions first, ensuring correctness and efficiency. For the MCQs, relied on my understanding of core CS concepts.

  • Outcome: Cleared the round successfully.

  • Round 2 - Telephonic Call:

  • Questions Asked:

    • Longest Palindromic Substring.

  • Your Approach: Explained my thought process clearly, starting with a brute-force approach and then optimizing it.

  • Outcome: Performed well and advanced to the next round.

  • Round 3 - Video Call:

  • Questions Asked:

    • Number of Islands in a grid (Graph problem).

  • Your Approach: Used Depth-First Search (DFS) to solve the problem, explaining each step while sharing my screen.

  • Outcome: Selected for the internship.

Preparation Tips:

  • Topics to Prepare: Data Structures, Pointers, OOPS, System Design, Algorithms, Dynamic Programming.
  • Time Required: 6 months of dedicated preparation.
  • Project Tip: Complete at least 3 major web development projects.
  • Practice Tip: Solve problems on platforms like InterviewBit.
  • Resume Tip: Keep it concise (1-2 pages) and include links to competitive coding profiles.

Conclusion:
Overall, the interview process was smooth and well-structured. I felt well-prepared due to my consistent practice and project work. For future candidates, I recommend focusing on problem-solving skills and clarity of thought during interviews. Also, ensure your resume highlights relevant projects and achievements.

10

Company Name: Amazon

Position: Software Developer Intern

Location: Bangalore

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

Interview Rounds:

  • Round 1 - Coding Test:

  • Questions Asked:

    1. Two Sum: Given an array of integers and a target value, find all pairs of elements that add up to the target. The solution needed to be optimized for O(N) time complexity.
    2. Merge Two Sorted Linked Lists: Merge two sorted linked lists into a single sorted linked list.

  • Your Approach: For the Two Sum problem, I used a hash map to store elements and their indices to achieve O(N) time complexity. For the linked list problem, I iterated through both lists, comparing nodes and merging them.

  • Outcome: Passed this round.

  • Round 2 - Video Call (Technical):

  • Questions Asked:

    1. Longest Consecutive Sequence: Given an unsorted array, find the length of the longest consecutive elements sequence.
    2. Two Sum in a BST: Determine if there exists a pair of nodes in a BST that sum up to a given target value.

  • Your Approach: For the consecutive sequence problem, I used a hash set to track elements and checked for sequences. For the BST problem, I performed an in-order traversal and used a two-pointer approach.

  • Outcome: The interviewer was friendly and provided hints when needed. Passed this round.

  • Round 3 - Video Call (Technical):

  • Questions Asked:

    1. Connect N Ropes With Minimum Cost: Given N ropes of different lengths, connect them into one rope with minimum cost.
    2. Zigzag Binary Tree Traversal: Perform a zigzag level order traversal of a binary tree.

  • Your Approach: For the ropes problem, I used a min-heap to always connect the two smallest ropes first. For the zigzag traversal, I used a queue and toggled the direction of traversal at each level.

  • Outcome: The interview was smooth, and the interviewer was supportive. Passed this round.

Preparation Tips:

  • Topics to Focus On: Data Structures, OOPS, Algorithms, Graph Traversal, Priority Queue.
  • Time Required: 6 months of consistent preparation.
  • Additional Tips:
    1. Practice standard Data Structures questions thoroughly.
    2. Ensure a strong command over the topics mentioned in your resume.
    3. Stay updated with the latest technology trends relevant to the job.

Conclusion:
Overall, the interview experience was positive. The interviewers were helpful, and the questions were challenging but manageable with proper preparation. I would advise future candidates to focus on problem-solving skills and to practice coding under time constraints. Having good projects on your resume and a clear understanding of them can also make a significant difference.

11

Company Name: Amazon

Position: Software Developer Intern

Location: Not specified

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

Interview Rounds:

  • Round 1 - Coding Test:

  • Questions Asked:

    • Two Sum: Given an array of integers and a target, find all pairs that add up to the target.
    • Bridges in a Graph: Find all critical edges in an undirected graph.

  • Your Approach:

    • For the Two Sum problem, I used a hashmap to store elements and their indices for O(N) time complexity.
    • For the Bridges problem, I applied Tarjan’s algorithm to detect bridges in the graph.

  • Outcome: Passed this round.

  • Round 2 - Video Call (Technical):

  • Questions Asked:

    • Circular Array Loop: Determine if there’s a cycle in a circular array.
    • LRU Cache Implementation: Design and implement an LRU cache.

  • Your Approach:

    • For the Circular Array Loop, I used a slow and fast pointer approach to detect cycles.
    • For the LRU Cache, I implemented it using a doubly linked list and a hashmap for O(1) operations.

  • Outcome: Passed this round.

  • Round 3 - Video Call (Technical):

  • Questions Asked:

    • Connect N Ropes with Minimum Cost: Given ropes of different lengths, connect them with minimum cost.
    • Langford Pairing: Arrange integers from 1 to N twice in a specific order.

  • Your Approach:

    • For the ropes problem, I used a min-heap to always connect the smallest ropes first.
    • For Langford Pairing, I initially struggled but explained my approach confidently and eventually coded it with the interviewer’s help.

  • Outcome: Passed this round and got selected.

Preparation Tips:

  • Focus on Data Structures, Recursion, Dynamic Programming, OOPS, and Pointers.
  • Spend at least 2.5 months preparing thoroughly.
  • Be very clear with the basics of each topic.
  • Be thorough with the projects mentioned in your resume.

Conclusion:
The interview process was challenging but rewarding. I felt well-prepared for the coding rounds, but the Langford Pairing question was tricky. The key was staying confident and communicating my thought process clearly. My advice to future candidates is to practice extensively and ensure you understand your projects inside out.

12

Company Name: Amazon

Position: Software Developer Intern

Location: Bangalore

Application Process: I applied through the campus placement process at my institute, Malaviya National Institute of Technology Jaipur. The eligibility criteria included a CGPA above 7 and no backlogs.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Amazing Strings: Given 3 strings, check whether the 3rd string contains all the characters of the first and second strings in any order. If all characters are present, print “YES”; otherwise, print “NO”.
      2. Longest Sub-string with at most K Distinct Characters: Find the length of the longest substring with at most K distinct characters.
    • Your Approach: For the first question, I used frequency counting to ensure all characters from the first two strings were present in the third. For the second question, I implemented a sliding window approach to track distinct characters efficiently.
    • Outcome: Passed this round successfully.

  • Round 2 - Telephonic Call:

    • Questions Asked:
      1. Longest Palindromic Substring: Given a string, find the longest palindromic substring.
    • Your Approach: I used dynamic programming to solve this problem, checking all possible substrings for palindromes.
    • Outcome: Cleared this round as well.

  • Round 3 - Video Call:

    • Questions Asked:
      1. Number of Islands: Given a grid of 0s and 1s, find the number of islands (a group of adjacent 1s).
    • Your Approach: I used Depth-First Search (DFS) to traverse the grid and count the islands.
    • Outcome: Successfully cleared this round and was selected for the internship.

Preparation Tips:

  • Topics to Focus On: Data Structures, Pointers, OOPS, System Design, Algorithms, and Dynamic Programming.
  • Time Required: I prepared for about 6 months.
  • Additional Tips:
    1. Complete at least 3 major web development projects.
    2. Practice coding problems from platforms like InterviewBit.

Conclusion:
Overall, the interview process was smooth and well-structured. The questions were aligned with my preparation, and I felt confident in my approach. If I could do anything differently, I would focus more on optimizing my solutions further. For future candidates, I recommend practicing a variety of problems and ensuring a strong grasp of fundamental concepts.

Final Outcome: Selected for the Software Developer Intern role at Amazon!

13

Company Name: Amazon

Position: Software Developer Intern

Location: Not specified

Application Process: The interview was conducted in September 2020. The process included an online assessment followed by two video call rounds.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Two Sum: Given an array of integers and a target, return all pairs of elements that add up to the target.
      2. Bridges in a Graph: Find all the bridges in a given undirected graph.
    • Your Approach: For the Two Sum problem, I used a hashmap to achieve O(N) time complexity. For the Bridges in a Graph problem, I applied a DFS-based approach to identify critical edges.
    • Outcome: Passed this round as I was able to solve both problems efficiently.

  • Round 2 - Video Call (Technical):

    • Questions Asked:
      1. Circular Array Loop: Determine if there’s a cycle in a circular array.
      2. LRU Cache Implementation: Design and implement an LRU cache.
    • Your Approach: For the Circular Array Loop, I used a slow and fast pointer approach. For the LRU Cache, I implemented it using a doubly linked list and a hashmap for O(1) operations.
    • Outcome: Successfully coded both solutions and explained the time and space complexities.

  • Round 3 - Video Call (Technical):

    • Questions Asked:
      1. Connect N Ropes with Minimum Cost: Given ropes of different lengths, connect them into one rope with minimum cost.
      2. Langford Pairing: Arrange integers from 1 to N twice in a specific order.
    • Your Approach: For the ropes problem, I used a min-heap to optimize the cost. The Langford Pairing was tricky, but I discussed my approach with the interviewer and eventually coded it.
    • Outcome: Cleared this round as well, despite initial difficulties with the second question.

Preparation Tips:

  • Focus on core topics like Data Structures, Recursion, Dynamic Programming, and OOPS.
  • Practice coding problems on platforms like LeetCode and GeeksforGeeks.
  • Be thorough with your projects and resume details.

Conclusion:
Overall, the interview process was rigorous but fair. The key was to stay calm and think logically. I could have prepared more for graph-based problems, but the interviewers were helpful. My advice to future candidates is to practice consistently and understand the fundamentals deeply.

14

Company Name: Amazon

Position: Software Developer Intern

Location: Hyderabad

Application Process: Applied through campus placement.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Subtree of Another Tree: Given two binary trees, check if one is a subtree of the other.
      2. Search In A Row Wise And Column Wise Sorted Matrix: Find a target value in a sorted matrix.
    • Your Approach: Solved both questions efficiently, focusing on tree traversal for the first and binary search for the second.
    • Outcome: Passed the round.

  • Round 2 - Video Call (Technical Interview 1):

    • Questions Asked:
      1. Maximum Of All Subarrays Of Size k: Find the maximum in all contiguous subarrays of size k.
      2. Chocolate Problem: Distribute chocolates among students with constraints.
      3. First Repeated Character: Find the first repeated character in a string.
    • Your Approach: Coded solutions for the first two and provided an approach for the third. Focused on clean code and meaningful variable names.
    • Outcome: Positive feedback; passed the round.

  • Round 3 - Video Call (Technical Interview 2):

    • Questions Asked:
      1. Snake and Ladder: Simulate the game and find the minimum steps to win.
    • Your Approach: Solved the problem with the interviewer’s help, emphasizing time and space complexity.
    • Outcome: Passed the round.

Preparation Tips:

  • Focus on data structures like Dynamic Programming, Graphs, LinkedList, Trees, and Bit Manipulation.
  • Practice medium-level questions on platforms like LeetCode.
  • Understand Amazon’s 14 leadership principles and incorporate them into your answers.
  • Ensure in-depth knowledge of projects listed on your resume.

Conclusion:
The interview process was smooth, with friendly interviewers who provided helpful hints. Writing clean code and explaining my thought process clearly were key to success. For future candidates, focus on problem-solving skills and quality over quantity in preparation.

15

Company Name: Amazon

Position: Software Developer Intern

Location: Not specified

Application Process: The interview process was conducted in November 2020. The application process included a coding test followed by two video call rounds.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Search in a row-wise and column-wise sorted matrix.
      2. Subtree of Another Tree (check if one binary tree is a subtree of another).
    • Your Approach: For the first question, I used a binary search approach to efficiently locate the target element in the matrix. For the second question, I implemented a recursive solution to compare the subtree structure and node values.
    • Outcome: Passed the round.

  • Round 2 - Video Call (Technical):

    • Questions Asked:
      1. Reachable Nodes (finding the number of nodes reachable from a given node in a graph).
      2. Squares of a Sorted Array (generating and sorting squares of array elements).
    • Your Approach: For the graph problem, I used BFS to traverse and count reachable nodes. For the array problem, I used a two-pointer approach to efficiently compute and sort the squares.
    • Outcome: Passed the round.

  • Round 3 - Video Call (Technical):

    • Questions Asked:
      1. Valid String (checking if a string with parentheses and asterisks is valid).
      2. Convert a binary tree to its sum tree (modifying a binary tree to a sum tree).
    • Your Approach: For the string problem, I used a greedy approach to validate the string. For the tree problem, I implemented a post-order traversal to compute the sum tree.
    • Outcome: Passed the round and received the internship offer.

Preparation Tips:

  • Focus on mastering data structures and algorithms, especially arrays, binary search, trees, graphs, and dynamic programming.
  • Practice coding problems on platforms like LeetCode, GFG, and InterviewBit.
  • Take mock interviews to build confidence and improve problem-solving speed.

Conclusion:
The interview process was challenging but well-structured. The interviewers were supportive and provided a conducive environment for problem-solving. Practicing a variety of problems and understanding core concepts were key to my success. For future candidates, I recommend consistent practice and thorough preparation of fundamental topics.

16

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.5.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Two Sum: Given an array of integers and a target value, find all pairs of elements that add up to the target.
      2. Merge Two Sorted Linked Lists: Merge two sorted linked lists into a single sorted linked list.
    • Your Approach: For the Two Sum problem, I used a hash map to store elements and their indices to achieve O(N) time complexity. For the linked list problem, I iterated through both lists, comparing nodes and merging them in sorted order.
    • Outcome: Passed this round.

  • Round 2 - Video Call (Technical):

    • Questions Asked:
      1. Longest Consecutive Sequence: Given an unsorted array, find the length of the longest consecutive elements sequence.
      2. Two Sum in a BST: Check if there exists a pair of nodes in a BST that sums up to a given target value.
    • Your Approach: For the longest consecutive sequence, I used a hash set to track elements and iterated to find sequences. For the BST problem, I performed an in-order traversal and used a two-pointer approach.
    • Outcome: The interviewer was friendly and provided hints when needed. Passed this round.

  • Round 3 - Video Call (Technical):

    • Questions Asked:
      1. Connect N Ropes With Minimum Cost: Given ropes of different lengths, connect them into one rope with minimum cost.
      2. Zigzag Binary Tree Traversal: Traverse a binary tree in a zigzag manner (left to right, then right to left, and so on).
    • Your Approach: For the ropes problem, I used a min-heap to always connect the two shortest ropes first. For the zigzag traversal, I used a queue and toggled the direction at each level.
    • Outcome: The interview was smooth, and the interviewer was supportive. Passed this round.

Preparation Tips:

  • Topics to Focus On: Data Structures, Algorithms, OOPS, Graph Traversal, and Priority Queues.
  • Time Required: Around 6 months of consistent preparation.
  • Tips:
    1. Practice standard Data Structures questions thoroughly.
    2. Ensure a strong command over the topics mentioned in your resume.
    3. Stay updated with the latest technology trends relevant to the role.

Conclusion:
Overall, the interview experience was positive. The interviewers were helpful and created a comfortable environment. I would advise future candidates to focus on problem-solving skills and clarity of thought. Having good projects on your resume and a solid understanding of core concepts is crucial. I was selected for the role, and I attribute my success to consistent practice and a clear understanding of fundamental concepts.

17

Company Name: Amazon

Position: Software Developer Intern

Location: Hyderabad

Application Process: I applied through the campus placement process at my college, Maharaja Agrasen Institute Of Technology. The eligibility criteria for the role required a CGPA above 7.5.

Interview Rounds:

  • Round 1 - Coding Test:

  • Questions Asked:

    • Flatten BST To A Sorted List: Convert a given BST into a right-skewed BST (sorted list).
    • Prerequisite Task: Determine if all tasks can be completed given dependencies.

  • Your Approach: For the BST problem, I used an in-order traversal to flatten the tree. For the task problem, I modeled it as a graph and checked for cycles using topological sorting.

  • Outcome: Passed this round and moved to the next stage.

  • Round 2 - Video Call (Technical Interview 1):

  • Questions Asked:

    • Sort Linked List: Given a linked list sorted by absolute values, sort it by actual values.
    • Convert BST To Greater Sum Tree: Modify the BST such that each node’s value is replaced by the sum of all greater values.

  • Your Approach: For the linked list, I used a two-pointer approach. For the BST problem, I performed a reverse in-order traversal to accumulate sums.

  • Outcome: Cleared this round and proceeded to the final interview.

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

  • Questions Asked:

    • Split the given array into K sub-arrays: Divide an array into K subarrays with minimal maximum sum.
    • (Second question not remembered).

  • Your Approach: For the array problem, I used binary search to find the minimal maximum sum.

  • Outcome: Unfortunately, I was rejected after this round.

Preparation Tips:

  • Topics to Focus On: Trees, Linked Lists, Graphs, Arrays, Binary Search.
  • Time Required: 3 months of dedicated preparation.
  • Tip 1: Strengthen your base by solving easy-level problems before moving to medium and hard ones.
  • Tip 2: Stay focused and persistent, even when facing challenges during preparation.

Conclusion:
Overall, the interview experience was rigorous but insightful. I realized the importance of a strong foundation in data structures and algorithms. For future candidates, I recommend practicing extensively on coding platforms and ensuring clarity in problem-solving approaches. While I didn’t make it this time, the experience has motivated me to improve further.

18

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.5.

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Two Sum: Given an array of integers and a target, return all pairs of elements that add up to the target.
      2. Merge Two Sorted Linked Lists: Merge two sorted linked lists into one combined sorted linked list.
    • Your Approach: For the Two Sum problem, I used a hash map to store elements and their indices to achieve O(N) time complexity. For the linked list problem, I iterated through both lists, comparing nodes and merging them.
    • Outcome: Passed this round.

  • Round 2 - Video Call (Technical):

    • Questions Asked:
      1. Longest Consecutive Sequence: Find the length of the longest consecutive sequence in an unsorted array.
      2. Two Sum in a BST: Determine if there exists a pair of node values in a BST that sum up to a target.
    • Your Approach: For the longest consecutive sequence, I used a hash set to track elements and checked for sequences. For the BST problem, I performed an in-order traversal and used a two-pointer approach.
    • Outcome: The interviewer was friendly and provided hints when needed. Passed this round.

  • Round 3 - Video Call (Technical):

    • Questions Asked:
      1. Connect N Ropes With Minimum Cost: Calculate the minimum cost to connect N ropes of different lengths.
      2. Zigzag Binary Tree Traversal: Perform a zigzag level order traversal of a binary tree.
    • Your Approach: For the ropes problem, I used a min-heap to always connect the two shortest ropes first. For the zigzag traversal, I used a queue and a flag to alternate the direction of traversal.
    • Outcome: The interview was smooth, and I felt comfortable. Passed this round.

Preparation Tips:

  • Topics to Focus On: Data Structures, Algorithms, OOPS, Graph Traversal, and Priority Queues.
  • Time Required: Dedicate at least 6 months for thorough preparation.
  • Resume Tips: Ensure your resume highlights relevant projects and skills. Be prepared to explain everything on your resume in detail.

Conclusion:
Overall, the interview experience was positive. The interviewers were helpful, and the questions were challenging but fair. I would advise future candidates to practice standard data structure problems and have a strong command of the topics mentioned on their resume. Also, stay calm and communicate your thought process clearly during the interview.

19

Company Name: Amazon

Position: Software Developer Intern

Location: Bangalore

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

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Two Sum: Given an array of integers and a target, find all pairs that add up to the target. The follow-up was to solve it in O(N) time complexity.
      2. Merge Two Sorted Linked Lists: Merge two sorted linked lists into one combined sorted linked list.
    • Your Approach: For the Two Sum problem, I used a hashmap to store elements and check for complements. For the linked list problem, I iterated through both lists, comparing nodes and merging them.
    • Outcome: Passed this round.

  • Round 2 - Video Call (Technical):

    • Questions Asked:
      1. Longest Consecutive Sequence: Given an unsorted array, find the length of the longest consecutive sequence.
      2. Two Sum in a BST: Check if there exists a pair of node values in a BST that sum up to a target.
    • Your Approach: For the longest consecutive sequence, I used a hashset to track elements and find sequences. For the BST problem, I performed an in-order traversal and used a two-pointer approach.
    • Outcome: The interviewer was friendly and provided hints when needed. Passed this round.

  • Round 3 - Video Call (Technical):

    • Questions Asked:
      1. Connect N Ropes With Minimum Cost: Given N ropes of different lengths, connect them into one rope with minimum cost.
      2. Zigzag Binary Tree Traversal: Perform a zigzag level order traversal of a binary tree.
    • Your Approach: For the ropes problem, I used a min-heap to always pick the two smallest ropes. For the zigzag traversal, I used a queue and alternated the direction of traversal.
    • Outcome: The interview was smooth, and I felt comfortable. Passed this round.

Preparation Tips:

  • Topics to Prepare: Data Structures, OOPS, Algorithms, Graph Traversal, Priority Queue.
  • Time Required: 6 months of consistent preparation.
  • Tips:
    1. Practice standard Data Structures questions thoroughly.
    2. Have a strong command over the topics mentioned in your resume.
    3. Stay updated with the latest technology domains relevant to the job.

Conclusion:
Overall, the interview experience was positive. The interviewers were supportive, and the questions were challenging but fair. I could have improved by practicing more problem variations and focusing on time management during the coding rounds. My advice to future candidates is to build a solid foundation in DSA and to be confident in explaining their thought process during interviews.

20

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

Interview Rounds:

  • Round 1 - Coding Test:

    • Questions Asked:
      1. Two Sum: Given an array of integers and a target, find all pairs that add up to the target. Follow-up: Solve in O(N) time complexity.
      2. Merge Two Sorted Linked Lists: Merge two sorted linked lists into one combined sorted linked list.
    • Your Approach: For the Two Sum problem, I used a hash map to store elements and their indices to achieve O(N) time complexity. For merging linked lists, I iterated through both lists, comparing nodes and merging them in sorted order.
    • Outcome: Passed this round.

  • Round 2 - Video Call (Technical):

    • Questions Asked:
      1. Longest Consecutive Sequence: Given an unsorted array, find the length of the longest consecutive elements sequence.
      2. Two Sum in a BST: Check if a BST contains two nodes that sum up to a target value.
    • Your Approach: For the longest consecutive sequence, I used a hash set to track elements and iterated to find sequences. For the BST problem, I performed an in-order traversal and used a two-pointer approach.
    • Outcome: The interviewer was friendly and provided hints when needed. Passed this round.

  • Round 3 - Video Call (Technical):

    • Questions Asked:
      1. Connect N Ropes With Minimum Cost: Given ropes of different lengths, connect them into one rope with minimum cost.
      2. Zigzag Binary Tree Traversal: Perform a zigzag level order traversal of a binary tree.
    • Your Approach: For the ropes problem, I used a min-heap to always connect the two shortest ropes first. For the zigzag traversal, I used a queue and toggled the traversal direction at each level.
    • Outcome: The interview was smooth, and I felt comfortable. Passed this round.

Preparation Tips:

  • Topics to Focus On: Data Structures, Algorithms, OOPS, Graph Traversal, Priority Queue.
  • Time Required: 6 months of dedicated preparation.
  • Resume Tips: Highlight good projects and ensure you have a strong command of the technologies mentioned in your resume.
  • Interview Tips: Practice standard Data Structures questions and be thorough with the topics on your resume.

Conclusion:
Overall, the interview experience was positive. The interviewers were helpful, and the questions were challenging but manageable with proper preparation. My advice to future candidates is to focus on problem-solving skills and to practice extensively on platforms like LeetCode and GeeksforGeeks. Also, ensure you understand the latest technology trends relevant to the role.