Samsung R&D India Interview Preparation 2026: SWC Test, DSA and Salary

Samsung's software hiring in India is unusual in one specific way: the main filter is not a standard HackerRank test with two medium problems, but a long, single-problem exam where you write everything from scratch and only a perfect solution counts. Candidates who are good at LeetCode but rely on unordered_map, sort and queue are often caught off guard.

This guide explains the commonly reported SWC test format, shows you exactly how to code without STL, walks through two fully solved Samsung-style problems in C++ and Java, describes the interviews after the test, and gives approximate salary ranges. Samsung adjusts its format by year, campus and test level, so always read the instructions given to you and confirm details with the placement cell or recruiter.

Samsung R&D Centres in India and What They Work On

Most software roles are C/C++, Java/Kotlin (Android) or Python for ML and tooling. Work often sits close to devices, which is one reason Samsung values implementation discipline and memory-conscious code.

Samsung R&D Hiring Flow for Freshers and Laterals

1. Shortlisting. On campus, by CGPA and branch criteria set per drive. Off campus and lateral, by resume, often via referrals or Samsung's careers portal.
2. SWC coding test. The main filter for software roles. Some drives add an aptitude or MCQ section; many do not.
3. Technical interview(s). One or two rounds. Interviewers often ask you to explain your test solution, then move to DSA, OOP, OS and projects.
4. HR interview. Relocation, team preferences, higher studies, and sometimes a discussion on the service agreement or joining terms if applicable.

Lateral candidates commonly report a similar coding test or a certification requirement, followed by technical rounds focused on their domain (Android, multimedia, networking, ML), and a managerial round. Samsung employees themselves take SWC certification levels internally, which is why the test is so central to the culture.

The SWC Test Format: What Candidates Report

Other commonly reported characteristics:

• The problem statement is long, often a story with a grid, robots, pipes, warriors or delivery routes. Reading it carefully is part of the test.
• Input has multiple test cases (T first, then each case), and output usually follows an exact format such as #1 13. A formatting slip fails everything.
• You can compile and run against sample inputs, but hidden tests include large and tricky cases you will not see.
• STL and library collections are frequently restricted, and some versions also restrict functions like abs from headers you are not allowed to include.
• The environment is Samsung's own platform, with limited IDE comforts. Practise in a plain editor.

How to Code Without STL: A Starter Kit

If you are used to vector, queue and sort, you need replacements you can type from memory in under five minutes. Fixed-size global arrays are your friend: problem constraints are small enough (grids up to around 50×50 or 100×100, item counts up to 10 to 20 for backtracking) that static arrays are simpler and faster.

// Circular-free simple queue: enough for BFS when each cell enters once
const int MAXQ = 10005;
int qr[MAXQ], qc[MAXQ], qd[MAXQ];
int qhead = 0, qtail = 0;
void qpush(int r, int c, int d) { qr[qtail] = r; qc[qtail] = c; qd[qtail] = d; qtail++; }
bool qempty() { return qhead == qtail; }

// Absolute value and min/max without <cstdlib> or <algorithm>
int iabs(int x) { return x < 0 ? -x : x; }
int imin(int a, int b) { return a < b ? a : b; }
int imax(int a, int b) { return a > b ? a : b; }

// Simple insertion sort, fine for n up to a few thousand
void isort(int a[], int n) {
    for (int i = 1; i < n; i++) {
        int key = a[i], j = i - 1;
        while (j >= 0 && a[j] > key) { a[j + 1] = a[j]; j--; }
        a[j + 1] = key;
    }
}

For larger inputs, also memorise merge sort and a binary heap with push/pop on an array, which you will need for Dijkstra on bigger graphs. Remember to reset global arrays between test cases; forgetting to clear a visited array is the most common reason correct logic fails on hidden tests. If you want a refresher on what the STL normally gives you, see the C++ STL guide, then practise living without it.

Samsung Coding Test Problem Types

Names like "Mr. Kim", "pipe problem", "wormholes" and "toll gates" circulate widely in candidate write-ups. You should practise these families, but do not expect your exact problem to repeat. The skill being tested is implementing a search correctly under constraints, which our grid problems and backtracking guides build systematically.

Solved Practice Problem 1: Pipe Grid Reachability (BFS)

Problem (Samsung style): An N×M grid has pipe types 0 to 7 in each cell (0 means no pipe). A fugitive starts at (R, C) and moves one cell per hour through connected pipes. Find how many cells he can be in within L hours (the start cell counts as hour 1). Two adjacent cells are connected only if the current pipe opens towards the neighbour and the neighbour's pipe opens back.

Approach: BFS from the start with distance 1. When popping a cell with distance d, if d equals L stop expanding it. For each of four directions, check the current pipe has that opening, the neighbour is in bounds, unvisited, non-zero, and has the opposite opening. Each cell is visited at most once: O(N·M) per test case.

#include <cstdio>

const int MX = 55;
int N, M, R, C, L;
int g[MX][MX];
bool vis[MX][MX];
int qr[MX * MX], qc[MX * MX], qd[MX * MX];

// direction order: 0=up, 1=down, 2=left, 3=right
int dr[4] = {-1, 1, 0, 0};
int dc[4] = {0, 0, -1, 1};
int opp[4] = {1, 0, 3, 2};
bool openDir[8][4] = {
    {0, 0, 0, 0},  // 0: no pipe
    {1, 1, 1, 1},  // 1
    {1, 1, 0, 0},  // 2
    {0, 0, 1, 1},  // 3
    {1, 0, 0, 1},  // 4: up, right
    {0, 1, 0, 1},  // 5: down, right
    {0, 1, 1, 0},  // 6: down, left
    {1, 0, 1, 0}   // 7: up, left
};

int solve() {
    for (int i = 0; i < N; i++)
        for (int j = 0; j < M; j++) vis[i][j] = false;   // reset per test case
    if (g[R][C] == 0 || L == 0) return 0;
    int head = 0, tail = 0, count = 1;
    qr[tail] = R; qc[tail] = C; qd[tail] = 1; tail++;
    vis[R][C] = true;
    while (head < tail) {
        int r = qr[head], c = qc[head], d = qd[head]; head++;
        if (d == L) continue;
        for (int k = 0; k < 4; k++) {
            if (!openDir[g[r][c]][k]) continue;
            int nr = r + dr[k], nc = c + dc[k];
            if (nr < 0 || nr >= N || nc < 0 || nc >= M) continue;
            if (vis[nr][nc] || g[nr][nc] == 0) continue;
            if (!openDir[g[nr][nc]][opp[k]]) continue;
            vis[nr][nc] = true;
            qr[tail] = nr; qc[tail] = nc; qd[tail] = d + 1; tail++;
            count++;
        }
    }
    return count;
}

int main() {
    int T;
    if (scanf("%d", &T) != 1) return 0;
    for (int t = 1; t <= T; t++) {
        scanf("%d %d %d %d %d", &N, &M, &R, &C, &L);
        for (int i = 0; i < N; i++)
            for (int j = 0; j < M; j++) scanf("%d", &g[i][j]);
        printf("#%d %d\n", t, solve());
    }
    return 0;
}

Dry run on a 3×3 grid, start (1,1), L = 2:

Start (1,1) has type 1 (all openings), distance 1, count 1. Up: (0,1) is type 2, which opens down (the opposite of up), so it is added with distance 2. Down: (2,1) type 2 opens up, added. Left: (1,0) type 3 opens right, added. Right: (1,2) type 3 opens left, added. Count is 5. Every cell at distance 2 equals L, so none expand. Answer: #1 5. If L were 1, the answer would be 1; if the start cell were 0, the answer would be 0, which is exactly the edge case many candidates miss.

Solved Practice Problem 2: Mr. Kim's Delivery Route (Backtracking)

Problem (Samsung style): Mr. Kim starts at his office, must visit all N customers (N ≤ 10) exactly once in any order, then go home. Distance between points is Manhattan distance |x1 − x2| + |y1 − y2|. Find the minimum total distance.

Approach: This is a small travelling-salesman instance. Backtracking over permutations is 10! ≈ 3.6 million leaves in the worst case, which is fine within the time limit when you prune any partial route already at or above the best answer. A bitmask DP alternative runs in O(2^N · N²), useful if N grows.

#include <cstdio>

int N, ox, oy, hx, hy;
int cx[12], cy[12];
bool used[12];
int best;

int iabs(int x) { return x < 0 ? -x : x; }
int dist(int x1, int y1, int x2, int y2) { return iabs(x1 - x2) + iabs(y1 - y2); }

void dfs(int px, int py, int visited, int sofar) {
    if (sofar >= best) return;                       // prune
    if (visited == N) {
        int total = sofar + dist(px, py, hx, hy);
        if (total < best) best = total;
        return;
    }
    for (int i = 0; i < N; i++) {
        if (used[i]) continue;
        used[i] = true;
        dfs(cx[i], cy[i], visited + 1, sofar + dist(px, py, cx[i], cy[i]));
        used[i] = false;                             // backtrack
    }
}

int main() {
    int T;
    scanf("%d", &T);
    for (int t = 1; t <= T; t++) {
        scanf("%d", &N);
        scanf("%d %d %d %d", &ox, &oy, &hx, &hy);
        for (int i = 0; i < N; i++) { scanf("%d %d", &cx[i], &cy[i]); used[i] = false; }
        best = 1000000000;
        dfs(ox, oy, 0, 0);
        printf("#%d %d\n", t, best);
    }
    return 0;
}

import java.io.*;
import java.util.StringTokenizer;

public class MrKim {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int T = Integer.parseInt(st.nextToken());
        StringBuilder out = new StringBuilder();
        for (int t = 1; t <= T; t++) {
            st = new StringTokenizer(br.readLine());
            int n = Integer.parseInt(st.nextToken());
            st = new StringTokenizer(br.readLine());
            int ox = Integer.parseInt(st.nextToken()), oy = Integer.parseInt(st.nextToken());
            int hx = Integer.parseInt(st.nextToken()), hy = Integer.parseInt(st.nextToken());
            int[] x = new int[n], y = new int[n];
            st = new StringTokenizer(br.readLine());
            for (int i = 0; i < n; i++) {
                x[i] = Integer.parseInt(st.nextToken());
                y[i] = Integer.parseInt(st.nextToken());
            }
            int full = 1 << n, INF = Integer.MAX_VALUE / 2;
            int[][] dp = new int[full][n];      // dp[mask][last] = min distance
            for (int[] row : dp) java.util.Arrays.fill(row, INF);
            for (int i = 0; i < n; i++)
                dp[1 << i][i] = Math.abs(ox - x[i]) + Math.abs(oy - y[i]);
            for (int mask = 1; mask < full; mask++)
                for (int last = 0; last < n; last++) {
                    if (dp[mask][last] == INF) continue;
                    for (int nxt = 0; nxt < n; nxt++) {
                        if ((mask & (1 << nxt)) != 0) continue;
                        int nm = mask | (1 << nxt);
                        int cand = dp[mask][last] + Math.abs(x[last] - x[nxt]) + Math.abs(y[last] - y[nxt]);
                        if (cand < dp[nm][nxt]) dp[nm][nxt] = cand;
                    }
                }
            int best = INF;
            for (int last = 0; last < n; last++)
                best = Math.min(best, dp[full - 1][last] + Math.abs(x[last] - hx) + Math.abs(y[last] - hy));
            out.append('#').append(t).append(' ').append(best).append('\n');
        }
        System.out.print(out);
    }
}

This Java version reads the customers on one line, so match the reader to the actual input format on test day. If the Java test restricts java.util, replace Arrays.fill with a plain loop and StringTokenizer with a manual parser. Also note the trade-off you would explain in an interview: backtracking is simpler and with pruning usually fast enough for N ≤ 10; bitmask DP is guaranteed polynomial in N times exponential, which is safer if N could be 15 or more. The bit manipulation guide covers the mask operations used here.

Samsung Technical and HR Interview Rounds

After the test, interviews are usually more relaxed than the test itself, but they are not a formality.

Technical interview topics

• Your SWC solution: explain the approach, complexity, and how you would handle a larger constraint. Interviewers sometimes ask you to rewrite part of it.
• DSA: linked lists, trees, BFS/DFS, sorting algorithms and their stability, hashing. Often easy to medium, sometimes on paper.
• OOP and C++/Java: polymorphism, virtual functions, abstract classes vs interfaces, memory allocation, smart pointers.
• Operating systems: processes vs threads, synchronisation, deadlock, memory management. Device-oriented teams may go deeper into Linux and Android internals. The OS interview questions guide is a good checklist.
• Projects: what you built, the hardest bug, what you would change.

HR interview

Expect questions on relocation (SRI-B vs SRI-N vs SRI-D), willingness to work on any domain allocated, higher studies plans, and joining terms. Ask HR to explain any service agreement or bond clause clearly before signing; terms differ by year and role.

Samsung R&D India Salary (2026)

Approximate 2026 ranges from public sources such as AmbitionBox, Glassdoor and levels.fyi; varies by team, location and negotiation. Titles and grade names vary between centres. Offers typically include fixed pay plus a performance-linked component; joining bonuses appear in some campus offers. Compare offers by in-hand pay, not headline CTC.

A 4-Week Samsung SWC Preparation Plan

The Samsung test rewards a specific kind of engineer: patient, careful and comfortable writing a hundred lines of plain code that works the first time. That skill is learnable in a few weeks of deliberate practice, and it pays off well beyond Samsung, including in Qualcomm and other systems-oriented interviews where clean C and C++ matter.

Frequently Asked Questions

Pranjal Jain

Ex-Microsoft SDE · IIT Kanpur · Founder of Prepflix. Helps engineers crack startup and product company interviews across India.