[New Grad] Samsung Electronics Coding Test Review (Samsung Research / Innovation Center)

Introduction

Samsung Electronics Samsung Research was one of the companies I really wanted to join, and from my graduate school days through after employment, I kept trying. Some attempts I went in barely prepared (right after starting work), but I'll focus on the ones where I prepared seriously. I originally posted the first attempt on a Naver blog; here I'm consolidating with everything since.

The purpose of this post is to share application result announcement dates and coding test schedules, things worth knowing before going into the exam room, and my thoughts/reflections. (I never passed the Samsung Electronics coding test, so I can't tell you how to study — only share what I went through.)

Samsung Electronics applications + coding test history

Samsung Electronics document screening — passed

(1st try: DX — Samsung Research) During graduate school

(2nd try DX — Samsung Research: 2022 H1, right after starting work — couldn't prepare, no records left)

(3rd try: DX — Samsung Research)

(4th try: DS — Innovation Center)

(5th try: DX — Device Platform Center)

Common notes across all rounds

Venue: DX division — Samsung Electronics Human Resources Development Institute / DS division — DS Dongtan Edu Center

Locations (map): Samsung Electronics HRDI / DS Edu Center Dongtan, in that order.

Seating: Very spacious, 1 person per seat.

Computer: Each station had a laptop + keyboard (or Desktop), plus 2 sheets of A4 paper.

Allowed languages: C++, Python, Java

Library restrictions:

For Python, some libraries are restricted. sys / sys.stdin.readline() are definitely not usable, and I remember itertools was also unavailable (a bit fuzzy on itertools). Languages other than Python had no special restrictions.

1. 1st Try review (during master's program)

Lesson #1: Match the submission format exactly.

State of mind during prep

I was preparing for graduation while job hunting, so I only had 11 days left to study algorithms. I jumped into Baekjoon, looked at past Samsung problems, and made a plan. I'd been writing deep RL / simulation code in my lab, but algorithm coding is a completely different game.

I didn't want to miss this chance, but the ~50 past Samsung problems on Baekjoon made me feel hopeless. Still, I told myself to do what I could, made a plan, and started tackling them one by one. The goal: walk into the exam room and solve just 1 of 2 problems perfectly.

Preparation

For context, I majored in mechanical engineering as an undergrad and only took an algorithms class during grad school. I barely knew BFS, DFS, data structures conceptually. Solving one problem took me a long time (up to 2 days), and I realized there's no way I could cover all the past problems at that pace, so I switched strategy. I focused on understanding the essence and type of just the 10 most recent problems. Thanks to that, I cleared all the recent shark-related problems except problem 21611 (Magician Shark and Blizzard, which time-outed).

The fastest way to get used to algorithm exams seems to be: think through what you'd implement, then read someone else's code to understand it. Keep asking why — why is this implementation easier this way, what are its characteristics. (Aligning the flow with your own thinking.) I repeated mental simulations until it felt familiar.

Thanks to that, what took 2 days at first started getting faster, and I felt my problem-solving speed picking up. Still, one problem took at least 2 hours to implement. People around me said for 2 solves you should finish the easy one in 1 hour ~ 1 hour 10 minutes and invest the rest in the hard one — but since my goal was always just 1 perfect solve, I didn't get greedy. I finished preparation that way.

In the exam room

When you arrive at the venue, they check your exam slip and direct you to your room. After sitting down and waiting a bit, the orientation starts and my heart started racing. Once the orientation ended and the exam began, the typing sounds started immediately. My heart was about to burst, but to keep my pace, I calmly worked through the problem on the A4 paper and started writing pseudo-code for the algorithm I had in mind.

The first problem I tackled: Dice Rolling 2 (Baekjoon 23288)

I had to implement the dice rolling, but that part was more confusing than I expected, so I implemented the rest first (the rest is just BFS + conditionals). About 20 minutes in, others were already typing furiously, and I was getting anxious. (Maybe I secretly wanted to solve fast in case I could attempt problem 2?) Eventually I got the dice working and finished in about 2h 10m ~ 2h 15m including debugging.

It took longer than expected, but I read all 10 sample test cases, printed them, and matched all 10. So I thought "OK I'm done! Time to submit!" — but I kept getting "No test cases match".

My mental state collapsed in real time. Wait... I matched all 10, how can not a single test case match?? I burned the remaining time trying to figure it out, changing outputs over and over. For reference, Samsung's input format also includes the number of test cases:

T = int(input())

for _ in range(1, T+1):
    ################################
    # write your code here
    ################################
    print("# %d" % score)

So I plugged my code into that template and output all 10 test cases as T=10. The output came out as # 33 # 61 # .. correctly, and the answers were right too, but I kept losing my mind trying to figure out what was wrong. With 2~3 minutes left, I noticed something in the example output:

# 1 33
# 2 61
# 3 361
...

Those numbers right after the # — that's the Test case numbering. Honestly even at that moment, I thought "no way it's failing because of that?" and didn't take it seriously. With only 3 minutes left, I couldn't fix it in time and submitted. Even right after the exam ended, I didn't realize that was the actual problem. Pathetic.

The next day I reconstructed the code, and once the problem appeared on Baekjoon, I submitted with the Baekjoon format. The code below is the Python version I reconstructed that day from memory of what I wrote in the exam.

[Dice Rolling 2 — Die rolling]

Dice implementation approach

Each time, I updated the [top, bottom, left, right] numbers centered on the current bottom face.

• When the dice rolls vertically, left/right stay the same. (Rolling down: current bottom moves up, the new bottom becomes 7 minus the new top. Rolling up: reverse.)
• When the dice rolls horizontally, top/bottom stay the same. (Rolling left: current bottom moves right, the new left becomes 7 minus the new right. Rolling right: reverse.)

from collections import deque

#T = int(input()) # Data set nums (existed in Samsung exam, commented out for Baekjoon)
N, M, K = list(map(int, input().split())) # row, column
board = [list(map(int, input().strip().split())) for _ in range(N)]

# up, down, left, right
dy = [-1,1,0,0]
dx = [0,0,-1,1]

def BFS(board,y,x):

    visit = [[False]*M for _ in range(N)]

    Q = deque()
    ref_value = board[y][x]
    count=0
    if visit[y][x] ==False:
        Q.append([y,x])
        visit[y][x] = True
        count=1

    while len(Q) != 0:

        y,x = Q.popleft()

        for _ in range(4):
            ny = y + dy[_]
            nx = x + dx[_]

            # boundary check
            if -1<nx<=M-1 and -1<ny<=N-1 and board[ny][nx] == ref_value and visit[ny][nx] == False:
                Q.append([ny,nx])
                count+=1
                visit[ny][nx] = True

    return ref_value, count

def die_move(cur_die, dir, un_fold):

    if dir==0: die_num = un_fold[0]; un_fold[1]=cur_die; un_fold[0]=7-cur_die # up
    if dir==1: die_num = un_fold[1]; un_fold[0]=cur_die; un_fold[1]=7-cur_die # down
    if dir==2: die_num = un_fold[2]; un_fold[3]=cur_die; un_fold[2]=7-cur_die # left
    if dir==3: die_num = un_fold[3]; un_fold[2]=cur_die; un_fold[3]=7-cur_die # right

    return die_num, un_fold

cur_die = 6
dir =3
un_fold = [2,5,4,3] # top/bottom/left/right (initial state for 6)
yo=0; xo=0
score = 0

for order in range(K):
    ny = yo + dy[dir]
    nx = xo + dx[dir]
    # wall bounce
    if nx<0: nx=1; dir=3
    if nx>M-1: nx=M-2;dir=2
    if ny>N-1: ny=N-2; dir=0
    if ny<0: ny=1; dir=1

    cur_die, un_fold = die_move(cur_die, dir, un_fold) # move dice
    board_num = board[ny][nx]
    ref_value, count = BFS(board,ny, nx) # BFS
    score += ref_value*count

    if cur_die < board_num: # turn left
        if dir==0: dir = 2; pass
        elif dir==1: dir = 3; pass
        elif dir==2: dir = 1; pass
        elif dir==3: dir = 0;

    if cur_die > board_num: # turn right
        if dir==0: dir = 3; pass
        elif dir==1: dir = 2; pass
        elif dir==2: dir = 0; pass
        elif dir==3: dir = 1;

    if cur_die == board_num:
        dir = dir
    yo =ny; xo=nx

print(score)

It ended up correct, confirming my algorithm was fine. The Baekjoon Samsung problem set doesn't have the Test case numbering, so I never picked it up. That feeling — like I'd solved it properly but gave it away. It may have been easy for others, but for me it was the result of real effort, and that one problem left a huge regret. (Unofficial 1-solve.)

Conclusion: {# Test Case Numbering Answer} — don't forget to print the test case number. Baekjoon doesn't require you to feed in Test cases yourself (your algorithm is graded directly), so it's easy to miss this part.

3. 3rd Try review (employed, exam time now 4 hours)

Lesson #3: When time is short, don't carelessly switch languages. Don't try to implement everything at once and debug at the end.

This was when I started applying to IT-related units (Innovation Center) rather than Samsung Research. You could say I gained confidence and IT familiarity while working. From this exam onward, Baekjoon doesn't have reconstructed problems anymore, so you'd practice on CodeTree instead.

Also, problem 1 stayed as a heavy implementation problem, but problem 2 changed to an API implementation problem (problem 2 leans more toward data structures — Linked List, Priority Queue, etc.).

State of mind during prep

At work I was doing web development in Java (not Python), so I naturally wanted to do well on the coding test in Java. So I started practicing Java problem-solving on Programmers and Baekjoon. Probably I wanted to build my expertise as a Java developer in my job.

Preparation (mid-September ~ October, one month)

I wasn't used to statically-typed languages, so it took quite a while to bring my Java up to coding-test level. Studying Java itself helped my actual job a lot, but on coding tests, I still got stuck often. Habits from Python made me naturally try ridiculous things like Java unpacking. After a month and a half of practice, I got somewhat comfortable doing coding tests in Java, but Samsung problems still took more time, and the line count was 1.5× or more compared to Python. I solved about 8~10 problems in Java and walked into the exam.

During this prep, I touched various heavy-implementation problem types — BFS, DFS, brute force, backtracking — and I think I built decent skills.

* Every day after work I practiced coding tests + studied programming languages. It helped a lot at work, but I'd recommend taking the test in the language you're most comfortable with.

In the exam room

My strategy this time was based on previous experience of frequently restarting after vaguely understanding problems: this time, finish the algorithm design completely first, then start implementing. The problem is linked below.

CodeTree — Battle GroundNational-team-built coding study guide. Curriculum from absolute beginners to dream-company coding tests.www.codetree.ai

So I spent about 1 hour finishing the algorithm design, then started implementing the entire thing in one go without intermediate checks, and only began debugging at the end. This approach was insane. If you're a true master, sure, you can implement once and pass. I wasn't at that level (or was I deluded?). I thought I'd designed perfectly, but there were still plenty of holes and mistakes. I got stuck mid-way, fumbled, and gave up. Even with 1 extra hour compared to previous exams, I couldn't implement properly and walked out blank. Genuinely deflating. Through this exam, I realized checking each method with test cases as you go is the right approach.

I came back later and solved the problem, pushed to GitHub. (BattleField.java)

Algorithm-Samsung/JavaVersion · taehyuklee/AlgorithmRepository tracking problems solved on online judges (Baekjoon · Programmers · Softeer · CodeTree).github.com

Conclusion: Don't switch to a less-familiar language for the coding test, and don't try to implement everything in one go and debug at the end.

4. 4th Try review — employed

Lesson #4: Hmm...??

By this point, it looks like Samsung Electronics' algorithm exam just doesn't suit me. (After moving to SK Inc. C&C as a junior re-hire, I took my 5th exam as well. Last lingering attachment, I guess.)

State of mind during prep (late August ~ October, one month)

Before my career got too established, I really wanted to move (within 2 years of starting work) as a junior re-hire. Samsung Electronics — the company I always wanted — kept being on my mind, and I'd been developing solutions in Java and taking coding tests for a while. I decided to bet everything on it as my last shot. I focused on coding test practice after work, even using vacation days.

In the last week, I managed my condition and adjusted my biorhythm to match the morning exam time. Every evening after dinner, from 8 PM to 12 AM, I practiced solving 2 problems within the given 4 hours. Thanks to that, I could implement Samsung's preferred problem types (spiral coordinates, periodic boundary conditions, bounce-back direction switching, etc.) on sight. That's how desperate I was...

In the exam room

I'd practiced realistically enough that I went in feeling fairly confident. I worked hard on the problem, focusing on getting all test cases to pass through some implementation (I didn't worry much about Hidden Cases since it was the A-type exam). The first implementation problem I tackled is linked below.

A monstrous problem (Rudolph's Rebellion from that round)

CodeTree — Rudolph's RebellionNational-team-built coding study guide. Curriculum from absolute beginners to dream-company coding tests.www.codetree.ai

At the exam venue, it felt like the problem statement just kept going on and on. Each year, beyond pure implementation ability, accurate problem comprehension was getting more important. The key points of the problem — the knockback effect and the chain reaction where pushing a person pushes the next person — I implemented beautifully with recursion. But I made a mistake at the simplest part. The problem asked for Manhattan distance (L1 Norm), and I implemented it as a BFS (totally unnecessary), which started causing errors.

I implemented the hard part well but made a mistake in the easy part. With 1h 30m to go, the implementation was done, but starting from test case 6~7 out of 10, it kept failing. My brain was already exhausted, and debugging wasn't going well, but with 1h 30m left, I kept grinding. In the end, debugging failed all the way through, and I had to submit it as-is.

I came back later, re-solved the problem, and pushed it to GitHub (2024-루돌프 소싸움 최종본.java)

Algorithm-Samsung/2024-The first Half-SamsungReconstructed code for Samsung 2024 H1 coding test — Rudolph's Rebellion etc.github.com

Conclusion: Rather than calling it "not enough practice," I think Samsung Electronics' algorithm exam just doesn't suit me anymore.

5. 5th attempt

The 5th attempt happened after my move to SK — team assignment and a chaotic time meant I have nothing meaningful to share, so I'm just sharing the schedule.

Closing thoughts

The long journey with Samsung Electronics ends here. I don't know if I'll cross paths with them again, but I'm endlessly grateful to the HR team for repeatedly passing my application. If the opportunity comes, I'll try the experienced-hire route.

And here's the post I wrote summarizing the implementation patterns that frequently come up in Samsung Electronics coding tests:

Samsung Electronics Coding Test — Recurring Implementation Modules (Java)7 implementation modules that recur in Samsung simulation problems — 90° rotation, periodic boundary, reverse direction, multi-key Sort, BFS, Spiral, concurrent List remove.taystudios.com/blog

To everyone taking the Samsung Electronics coding test — good luck! Hope this helps a little.