Samsung Interviews

I recently participated in an actual on-campus coding round conducted by Samsung at my college. In Round 1, we were given 3 hours to solve a single problem. The question involved a square matrix, seven types of pipes, each allowing movement in specific directions, a starting position, and the task was to compute the maximum number of reachable steps from that position through valid pipe connections.

Many of my peers attempted this problem using DFS. Out of 50 test cases, those who used DFS typically passed around 42. However, candidates who used BFS received a perfect 50/50. That round made one thing crystal clear to me: while DFS can explore, BFS guarantees correctness whenever distance, levels, or minimal steps matter. This insight led me to understand exactly why BFS worked flawlessly in that problem, and more importantly, when BFS is the right tool.

I recently took part in the Samsung Software Development Engineer (SDE) Online Assessment for their 2025 on-campus hiring drive. The coding round was straightforward, presenting just one question. This problem was a variant of the well-known LeetCode Burst Balloons problem. The main differentiator was the scoring mechanism for bursting a balloon, which was slightly altered from the standard version. Successful candidates who passed all 50 test cases were then shortlisted for the subsequent interview rounds.

College: Tier-1 NIT
Years of Experience: 2 years

Round 1: Online Test (Medium to Tough Level)

Round 2: Technical Interview (1 hour)

Round 3: HR Discussion & Technical Info (30 minutes)

Given an array original array say y = [1,2,3,4,5] each day an addition array say x = [2,1,6,7,8] this is added to it. Now we need to find in which min day the total sum will be less than M. At each day we can remove any one element from the array. ex: Day 0 : [1,2,3,4,5] Now sum = 15 if its less than M then 0 is our answer. Note: On day 0 we don't remove any element. Day1: [1,2,3,4,5] + [2,1,6,7,8] = [3,3,9,11,13] Now we can remove any element say 11 . Now the sum is 3+3+9+0+13 = 28 if its less than M, then Day1 is our answer. if we can't achieve this then return -1.

Day2: [3,3,9,0,13] + [2,1,6,7,8] = [5,4,15,7,21] Now we can select any one element to remove say 15. so array becomes : [5,4,0,7,21]

and so on......

Constraints: M<10^6> Size of Array : N<20

Test Case 1: M = 1 original Array = [10,15] Daily Addition Array = [3,2] Ans = -1

Test Case 2: M = 33 original Array = [7,3,5,6,8,0,8] Daily Addition Array = [2,4,1,1,2,3,1] Ans = 6

Test Case 3: M = 92 original Array = [35,58,39] Daily Addition Array = [30,20,10] Ans = 2

Test Case 4: M = 905 original Array = [170,203,171,42,60,111,152] Daily Addition Array = [60,32,63,65,70,50,63] Ans = -1

I recently took a coding assessment where one of the problems was based on a very interesting twist on greedy + two-pointer + sorting techniques — and I wanted to share the question for the community.

You're on a haunted straight road of length L with N ghosts positioned along it.

Each ghost is described by:

A position A[i] on the road (0 ≤ A[i] ≤ L)

A stamina level B[i]

You are allowed to trap exactly one ghost, and this ghost becomes your trap ghost. Starting from this position, you can move only to the right, hunting more ghosts under the following rules:

Rules for hunting: You may only hunt ghosts whose stamina is greater than or equal to the trap ghost's stamina.

Hunting a ghost costs energy equal to:

(distance from the trap)×(ghost’s stamina)

The total energy used must not exceed a given limit E.

Goal: Determine the maximum number of ghosts you can hunt including the trap ghost, under the above constraints.

Input:
L = 20  
N = 5  
E = 100  

A = [2, 5, 10, 14, 18]  
B = [3, 2, 4, 5, 6]

Output: 3

Explanation:

• If you trap the ghost at position 10 with stamina 4
• You can hunt ghosts at positions 14 (stamina 5) and 18 (stamina 6)
  • Cost to hunt at 14: (14 - 10) * 5 = 20
  • Cost to hunt at 18: (18 - 10) * 6 = 48
  • Total cost: 20 + 48 = 68 ≤ 100
• Total ghosts hunted = 3 (at positions 10, 14, 18)

🪓 Problem: Logging Roadside Trees

The Korean Expressway Corporation is planning to expand the road where the volume of traffic is high. In order to expand the road, all the roadside trees nearby the road have to be chopped down.

To do this efficiently, they will rent a logging robot. However, the rental fee is high due to the high production cost, so we want to minimize the time taken by the robot.

🧠 The Logging Robot Has the Following Features:

1. The robot can move forward and backward.
   • Moving 1 unit takes 1 minute.
2. The roadside trees (left or right side) can be cut and loaded, which takes 1 minutes per tree.
3. Trees must be loaded in the order of their cut.
   • Only a tree whose length is shorter than or equal to the previously loaded tree can be loaded.
   • (i.e., non-increasing order of tree lengths)
4. If there are trees on both sides (left and right), without moving, each can be cut and loaded if the above order condition is satisfied.
5. The robot can load an infinite number of trees.

📐 Road Layout Description:

• The road is given as a straight line with a length of N.
• The first point (position 0) is the starting point.
• The last point (position N) is the ending point.
• On each side (left and right), there may be one tree at most at every unit length, with varying lengths.
• It is possible that there are no trees at a particular position.
• At the starting and ending points, there are no trees planted.

📋 Input Format:

1. The first line is an integer N — the length of the road.
2. The next two lines contain the lengths of the trees at each point from 0 to N:
   • First line: L — tree lengths on the left side.
   • Second line: R — tree lengths on the right side.
   • If there is no tree at a position, the length is given as 0.

🧾 Output Format:

Print the shortest time (in minutes) that is required to cut down all the trees, starting from the starting point to the ending point.

🧪 Example:

Example 1:

N = 5
L = 0 3 2 1 0 0
R = 0 3 2 1 0 0
Output: 11 minutes

Example 2:

N = 7
L = 0 5 1 5 9 1 5 0
R = 0 0 0 0 0 0 0 0
Output: 23 minutes

Example 3:

N = 10
L = 0 7 3 5 7 7 1 0 5 8 0
R = 0 7 7 0 1 0 1 1 0 0 0
Output: 51 minutes

Given N medicine bottles and M containers and each container has capacity to carry W[i] bottles. The delivery van can take two containers (only one can also be loaded) to nearby hospital in single trip. Containers can be reused. Find number of trips to deliver minimum N bottles. If not possible, print -1

Contraints 1 <= N,M,W[i] <= 1000 W.length == M

N = 5, M = 2 W[] = {1, 3} Output = 2

N = 6, M = 2 W[] = {4, 5} Output = -1

N = 720, M = 5 W[] = {27, 52, 119, 144, 124} Output = 5

I tried using 2d/3d DP but got TLE.

My Samsung Advanced Developer Interview Experience

During my interview, the discussion started with an in-depth exploration of my internship project at Samsung R&D, Bangalore. The interviewer probed me about potential single points of failure within the project and asked how I would approach addressing them. We also delved into the significance of 'doChoreographer' frames and how they could be utilized to pinpoint performance bottlenecks.

Following this, the focus shifted to fundamental Data Structures and Algorithms. I was asked about various traversal algorithms for trees and graphs, with an emphasis on their real-world applications and use cases.

The interviewer then presented two aptitude questions that required logical reasoning and problem-solving:

1. The Scooter and Tires problem.
2. The Weighing Coins problem.

After these aptitude challenges, we transitioned back to Data Structures and Algorithms. The conversation covered Dijkstra's Algorithm, Bellman-Ford, and Floyd-Warshall, where I discussed their time and space complexities. There was also a brief mention of a dynamic programming problem involving directed graphs that had appeared in the SWC Advanced test.

Finally, the interview concluded with a discussion on core Computer Science fundamentals, including semaphores, threads, locking mechanisms, critical sections, race conditions, and various strategies to handle these concurrency issues. Throughout the entire interview, I felt the emphasis was predominantly on assessing my problem-solving capabilities and logical thinking rather than just theoretical recall.

I interviewed for a New Grad Software Engineer position at Samsung R&D Bangalore. My journey started with two coding rounds, followed by a detailed technical interview, and concluded with a brief HR discussion.

Coding Round 1 (Cocubes Round) - July 15, 2022

Coding Round 2 (SWC Advanced Test) - July 21, 2022

Technical Round 1 - August 5, 2022

Following the DSA problems, the discussion moved to OOPS (C++) and Operating Systems. I was asked several conceptual questions, some of which required me to write code examples to illustrate my understanding. The interviewer was very supportive throughout this process. We then discussed my projects, specifically questions related to Android architecture and Flutter.

HR Round - August 8, 2022

I recently participated in the on-campus recruitment drive for Samsung R&D India, targeting 2020 graduates. The entire process involved four rounds: one online exam, two technical interviews, and one HR/managerial interview.

Round 1: Online Exam

The first round was an online exam conducted on Samsung's internal platform, the Samsung SWC exam platform. It featured just one coding question, but it was to be completed in 3 hours. The difficulty was medium-hard, leaning more towards hard. The crucial aspects were:

• Clearing almost 50 test cases, with success required for every single one.
• No autocomplete IDE features were allowed.
• No standard libraries could be used, other than print statements, which meant creating my own data structures like HashMap.

The questions typically cover DP, Hash, Heap, and Arrays. My specific question was a variation of the Burst Balloons problem.

Round 2: First Technical Round

This was a face-to-face round focused on my projects, technical depth in core subjects, and Data Structures & Algorithms (DSA). Since I worked with Java, I was questioned extensively on topics like Java OOPS, immutability, Garbage Collection (GC) mechanics, and String pool concepts.

For DSA, I had to write code snippets on paper, which emphasized the importance of writing clean, proper, and understandable code without mistakes. The topics covered included:

• Linked List: finding loops, meeting points, and reversal. I discussed problems similar to Reverse Linked List and Linked List Cycle II.
• Tree: mirroring and shortest path to a leaf. I was asked questions similar to Symmetric Tree.
• Heaps: finding the median of a continuous stream of data, similar to Find Median from Data Stream.

Self-confidence was key here; the interviewers were friendly and helpful, encouraging me to give my best approach even if I made a mistake.

Round 3: Second Technical Round

This round followed quickly after the first technical one, covering DSA, algorithms, core subject basics, and some puzzles. Again, code was written on paper. Key topics included:

• Linked List: Re-emphasizing loop detection, but this time requiring a mathematical explanation/proof for why the fast pointer skips two nodes in the 'fast and slow pointers' method. Understanding the depth of answers was crucial.
• DP, Backtracking, Tree: General discussions and problem-solving.

Core subjects included Security and Encryption (RSA, Symmetric/Asymmetric encryption), Database basics (ACID properties), and Networking basics (subnetting, HTTP request/response). I was also asked 1-2 general puzzles. Staying calm and trying every question, rather than giving up, was essential in this round, which aimed to test patience and resilience.

Round 4: HR/Managerial Round

The final round was with the HR head, lasting about 30-40 minutes. It covered standard HR questions about hobbies, future vision, and discussions based on my resume, including my Java and Machine Learning projects. Some mathematical puzzles were also part of this round.

The results were announced the next day, and I was fortunate to be one of the selected candidates for an Intern + FTE role.