Samsung Interview Questions 2026
28 min read
Interview Questions
Advertisement Placement
Samsung R&D Interview Questions 2026 - C, OS & Data Structures Focus
Samsung R&D Overview
| Attribute | Details |
|---|---|
| Founded | 1969 (R&D India: 1996) |
| Headquarters | Suwon, South Korea (India: Bangalore, Noida) |
| Employees in India | 25,000+ |
| R&D Focus | Mobile, Semiconductor, Display, Network |
| Key Products | Galaxy Smartphones, Exynos Processors, Memory |
| India Labs | SRI-B (Bangalore), SRI-N (Noida) |
Samsung R&D Institute India is Samsung's largest R&D center outside Korea, working on flagship mobile products, Tizen OS, and next-generation technologies.
Samsung R&D Interview Process 2026
Hiring Divisions
| Division | Focus | Skills Required |
|---|---|---|
| Mobile R&D | Android, System Optimization | C/C++, Java, OS |
| Advanced Technology | AI/ML, Computer Vision | Python, C++, Algorithms |
| Semiconductor | Exynos, Memory | Verilog, C, Architecture |
| Network | 5G, Communication | C, Protocols, Signal Processing |
Selection Stages
| Stage | Duration | Format |
|---|---|---|
| GSAT (General Samsung Aptitude Test) | 90 mins | Quant + Reasoning + Technical |
| Technical Round 1 | 60 mins | Coding + CS Fundamentals |
| Technical Round 2 | 60 mins | Advanced DS/Algo + System Design |
| Technical Round 3 | 45 mins | Domain Expertise |
| HR Interview | 30 mins | Behavioral, Compensation |
GSAT (General Samsung Aptitude Test) Pattern
Section-wise Breakdown
| Section | Questions | Time | Topics |
|---|---|---|---|
| Quantitative Aptitude | 25 | 35 mins | Arithmetic, Algebra, Geometry |
| Logical Reasoning | 20 | 25 mins | Puzzles, Data Sufficiency |
| Verbal Ability | 15 | 20 mins | RC, Grammar, Vocabulary |
| Technical (C/DS) | 20 | 30 mins | Pointers, Arrays, Output tracing |
| Total | 80 | 110 mins | - |
C Programming Questions
Question 1: Pointer Output Tracing
#include <stdio.h>
int main() {
int arr[] = {10, 20, 30, 40, 50};
int *ptr = arr;
// Question 1
printf("%d ", *ptr++); // Output: 10 (post-increment)
printf("%d ", *ptr); // Output: 20
// Question 2
int *ptr2 = arr;
printf("%d ", ++*ptr2); // Output: 11 (pre-increment value)
printf("%d ", *ptr2); // Output: 11
// Question 3 - Pointer arithmetic
int *p1 = arr;
int *p2 = &arr[3];
printf("%ld ", p2 - p1); // Output: 3 (elements between)
// Question 4 - 2D array
int matrix[3][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
printf("%d ", *(*(matrix+1)+2)); // Output: 7 (matrix[1][2])
printf("%d ", *(matrix[1]+2)); // Output: 7
return 0;
}
Question 2: Memory Layout and Storage Classes
#include <stdio.h>
// Data segment - initialized global
int global_var = 100;
// BSS segment - uninitialized global
static int static_global;
// Code segment (Text)
void function() {
// Stack
int local_var = 50;
// Static - Data segment
static int static_local = 200;
// Heap
int *heap_var = (int *)malloc(sizeof(int));
printf("Global: %p\n", &global_var);
printf("Static Global: %p\n", &static_global);
printf("Local: %p\n", &local_var);
printf("Static Local: %p\n", &static_local);
printf("Heap: %p\n", heap_var);
}
// Common output tracing questions:
void test_storage() {
static int count = 0; // Retains value between calls
count++;
printf("%d ", count);
}
// Calling test_storage() 3 times outputs: 1 2 3
Question 3: Preprocessor and Macros
#include <stdio.h>
#define SQUARE(x) ((x) * (x))
#define CUBE(x) (SQUARE(x) * (x))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define SWAP(a, b) { typeof(a) temp = a; a = b; b = temp; }
int main() {
// Common trick questions
int a = 5, b = 3;
printf("%d\n", SQUARE(a++)); // 25 (a becomes 7!)
// Expansion: ((a++) * (a++)) = 5 * 6 = 30 (undefined behavior)
printf("%d\n", MAX(a++, b++)); // Side effects issue
// Expansion: ((a++) > (b++) ? (a++) : (b++))
// Stringification
#define STR(x) #x
printf("%s\n", STR(Hello World)); // "Hello World"
// Token pasting
#define CONCAT(a, b) a##b
int xy = 10;
printf("%d\n", CONCAT(x, y)); // xy = 10
return 0;
}
Operating Systems Questions
Question 4: Process vs Thread
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
/* Process Creation */
void process_demo() {
pid_t pid = fork();
if (pid < 0) {
perror("Fork failed");
} else if (pid == 0) {
// Child process
printf("Child: PID=%d, Parent PID=%d\n", getpid(), getppid());
execlp("ls", "ls", "-l", NULL); // Replace process image
} else {
// Parent process
wait(NULL); // Wait for child
printf("Parent: Child PID=%d\n", pid);
}
}
/* Thread Creation (pthread) */
#include <pthread.h>
void* thread_function(void *arg) {
int *num = (int *)arg;
printf("Thread: ID=%lu, Arg=%d\n", pthread_self(), *num);
return NULL;
}
void thread_demo() {
pthread_t tid;
int value = 42;
pthread_create(&tid, NULL, thread_function, &value);
pthread_join(tid, NULL);
}
| Aspect | Process | Thread |
|---|---|---|
| Memory | Separate address space | Shares address space |
| Creation | Heavy (fork/exec) | Light (pthread_create) |
| Communication | IPC (pipes, sockets, shared memory) | Direct shared memory |
| Overhead | High | Low |
| Crash Impact | Only that process | Entire process |
| Context Switch | Expensive (MMU update) | Cheaper |
Question 5: Virtual Memory and Paging
/* Virtual Memory Concepts */
/* Page Table Structure (simplified) */
#define PAGE_SIZE 4096
#define NUM_PAGES 1024
typedef struct {
uint32_t present : 1; // Page in memory
uint32_t rw : 1; // Read/Write permission
uint32_t user : 1; // User/Supervisor
uint32_t accessed : 1; // Accessed bit
uint32_t dirty : 1; // Modified bit
uint32_t frame : 20; // Physical frame number
} PageTableEntry;
/* Address Translation */
#define VPN_MASK 0xFFC00000
#define OFFSET_MASK 0x003FFFFF
void translate_address(uint32_t virtual_addr) {
uint32_t vpn = (virtual_addr & VPN_MASK) >> 22;
uint32_t offset = virtual_addr & OFFSET_MASK;
PageTableEntry *pte = &page_table[vpn];
if (!pte->present) {
// Page fault - load from disk
handle_page_fault(vpn);
}
uint32_t physical_addr = (pte->frame << 22) | offset;
printf("VA: 0x%x -> PA: 0x%x\n", virtual_addr, physical_addr);
}
/* Page Replacement: LRU Implementation */
typedef struct {
uint32_t page_num;
uint32_t last_access;
} LRUPage;
uint32_t find_lru_page(LRUPage *pages, int num_pages) {
uint32_t lru_idx = 0;
uint32_t oldest = pages[0].last_access;
for (int i = 1; i < num_pages; i++) {
if (pages[i].last_access < oldest) {
oldest = pages[i].last_access;
lru_idx = i;
}
}
return lru_idx;
}
Question 6: Deadlock and Synchronization
#include <pthread.h>
#include <semaphore.h>
/* Mutex for mutual exclusion */
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void critical_section() {
pthread_mutex_lock(&mutex);
// Critical section
pthread_mutex_unlock(&mutex);
}
/* Semaphore for resource counting */
sem_t semaphore;
void init_resource(int count) {
sem_init(&semaphore, 0, count);
}
void use_resource() {
sem_wait(&semaphore); // P() - acquire
// Use resource
sem_post(&semaphore); // V() - release
}
/* Deadlock Example */
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
void* thread_a(void *arg) {
pthread_mutex_lock(&lock1);
sleep(1); // Force race condition
pthread_mutex_lock(&lock2); // May deadlock
// Critical section
pthread_mutex_unlock(&lock2);
pthread_mutex_unlock(&lock1);
return NULL;
}
void* thread_b(void *arg) {
pthread_mutex_lock(&lock2);
sleep(1);
pthread_mutex_lock(&lock1); // May deadlock
// Critical section
pthread_mutex_unlock(&lock1);
pthread_mutex_unlock(&lock2);
return NULL;
}
/* Solution: Lock ordering */
void safe_thread() {
// Always acquire lock1 before lock2
pthread_mutex_lock(&lock1);
pthread_mutex_lock(&lock2);
// Critical section
pthread_mutex_unlock(&lock2);
pthread_mutex_unlock(&lock1);
}
Deadlock Conditions (Coffman Conditions):
- Mutual Exclusion: Resources cannot be shared
- Hold and Wait: Process holds resources while waiting
- No Preemption: Resources cannot be forcibly taken
- Circular Wait: Circular chain of waiting processes
Data Structures Questions
Question 7: Stack Implementation
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define STACK_SIZE 100
typedef struct {
int items[STACK_SIZE];
int top;
} Stack;
void init_stack(Stack *s) {
s->top = -1;
}
bool is_empty(Stack *s) {
return s->top == -1;
}
bool is_full(Stack *s) {
return s->top == STACK_SIZE - 1;
}
void push(Stack *s, int value) {
if (is_full(s)) {
printf("Stack Overflow\n");
return;
}
s->items[++s->top] = value;
}
int pop(Stack *s) {
if (is_empty(s)) {
printf("Stack Underflow\n");
return -1;
}
return s->items[s->top--];
}
int peek(Stack *s) {
if (is_empty(s)) {
return -1;
}
return s->items[s->top];
}
/* Stack using Linked List */
typedef struct Node {
int data;
struct Node *next;
} Node;
typedef struct {
Node *top;
} StackLL;
void push_ll(StackLL *s, int value) {
Node *new_node = (Node *)malloc(sizeof(Node));
new_node->data = value;
new_node->next = s->top;
s->top = new_node;
}
int pop_ll(StackLL *s) {
if (s->top == NULL) {
return -1;
}
Node *temp = s->top;
int value = temp->data;
s->top = temp->next;
free(temp);
return value;
}
Question 8: Binary Search Tree Operations
#include <stdio.h>
#include <stdlib.h>
typedef struct TreeNode {
int data;
struct TreeNode *left;
struct TreeNode *right;
} TreeNode;
TreeNode* create_node(int value) {
TreeNode *new_node = (TreeNode *)malloc(sizeof(TreeNode));
new_node->data = value;
new_node->left = NULL;
new_node->right = NULL;
return new_node;
}
TreeNode* insert(TreeNode *root, int value) {
if (root == NULL) {
return create_node(value);
}
if (value < root->data) {
root->left = insert(root->left, value);
} else if (value > root->data) {
root->right = insert(root->right, value);
}
return root;
}
TreeNode* find_min(TreeNode *root) {
while (root->left != NULL) {
root = root->left;
}
return root;
}
TreeNode* delete_node(TreeNode *root, int value) {
if (root == NULL) return root;
if (value < root->data) {
root->left = delete_node(root->left, value);
} else if (value > root->data) {
root->right = delete_node(root->right, value);
} else {
// Node found
if (root->left == NULL) {
TreeNode *temp = root->right;
free(root);
return temp;
} else if (root->right == NULL) {
TreeNode *temp = root->left;
free(root);
return temp;
}
// Node with two children
TreeNode *temp = find_min(root->right);
root->data = temp->data;
root->right = delete_node(root->right, temp->data);
}
return root;
}
/* Traversals */
void inorder(TreeNode *root) {
if (root != NULL) {
inorder(root->left);
printf("%d ", root->data);
inorder(root->right);
}
}
void preorder(TreeNode *root) {
if (root != NULL) {
printf("%d ", root->data);
preorder(root->left);
preorder(root->right);
}
}
void postorder(TreeNode *root) {
if (root != NULL) {
postorder(root->left);
postorder(root->right);
printf("%d ", root->data);
}
}
/* Check if BST */
bool is_bst_util(TreeNode *root, int min, int max) {
if (root == NULL) return true;
if (root->data < min || root->data > max) {
return false;
}
return is_bst_util(root->left, min, root->data - 1) &&
is_bst_util(root->right, root->data + 1, max);
}
bool is_bst(TreeNode *root) {
return is_bst_util(root, INT_MIN, INT_MAX);
}
Question 9: Graph Algorithms
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <limits.h>
#define MAX_VERTICES 100
#define INF INT_MAX
/* Adjacency Matrix */
int adj_matrix[MAX_VERTICES][MAX_VERTICES];
/* BFS */
void bfs(int start, int n) {
bool visited[MAX_VERTICES] = {false};
int queue[MAX_VERTICES];
int front = 0, rear = 0;
visited[start] = true;
queue[rear++] = start;
while (front < rear) {
int curr = queue[front++];
printf("%d ", curr);
for (int i = 0; i < n; i++) {
if (adj_matrix[curr][i] && !visited[i]) {
visited[i] = true;
queue[rear++] = i;
}
}
}
}
/* DFS */
void dfs_util(int v, int n, bool visited[]) {
visited[v] = true;
printf("%d ", v);
for (int i = 0; i < n; i++) {
if (adj_matrix[v][i] && !visited[i]) {
dfs_util(i, n, visited);
}
}
}
void dfs(int start, int n) {
bool visited[MAX_VERTICES] = {false};
dfs_util(start, n, visited);
}
/* Dijkstra's Shortest Path */
void dijkstra(int src, int n) {
int dist[MAX_VERTICES];
bool visited[MAX_VERTICES] = {false};
for (int i = 0; i < n; i++) {
dist[i] = INF;
}
dist[src] = 0;
for (int count = 0; count < n - 1; count++) {
// Find minimum distance vertex
int min = INF, u;
for (int v = 0; v < n; v++) {
if (!visited[v] && dist[v] <= min) {
min = dist[v];
u = v;
}
}
visited[u] = true;
// Update distances
for (int v = 0; v < n; v++) {
if (!visited[v] && adj_matrix[u][v] &&
dist[u] != INF &&
dist[u] + adj_matrix[u][v] < dist[v]) {
dist[v] = dist[u] + adj_matrix[u][v];
}
}
}
// Print distances
printf("Vertex\tDistance from Source\n");
for (int i = 0; i < n; i++) {
printf("%d\t%d\n", i, dist[i]);
}
}
Algorithm Questions
Question 10: Sorting Algorithms
/* Quick Sort */
void quick_sort(int arr[], int low, int high) {
if (low < high) {
int pi = partition(arr, low, high);
quick_sort(arr, low, pi - 1);
quick_sort(arr, pi + 1, high);
}
}
int partition(int arr[], int low, int high) {
int pivot = arr[high];
int i = low - 1;
for (int j = low; j < high; j++) {
if (arr[j] < pivot) {
i++;
swap(&arr[i], &arr[j]);
}
}
swap(&arr[i + 1], &arr[high]);
return i + 1;
}
/* Merge Sort */
void merge_sort(int arr[], int left, int right) {
if (left < right) {
int mid = left + (right - left) / 2;
merge_sort(arr, left, mid);
merge_sort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}
void merge(int arr[], int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;
int L[n1], R[n2];
for (int i = 0; i < n1; i++) L[i] = arr[left + i];
for (int j = 0; j < n2; j++) R[j] = arr[mid + 1 + j];
int i = 0, j = 0, k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) arr[k++] = L[i++];
else arr[k++] = R[j++];
}
while (i < n1) arr[k++] = L[i++];
while (j < n2) arr[k++] = R[j++];
}
| Algorithm | Time (Best) | Time (Avg) | Time (Worst) | Space | Stable |
|---|---|---|---|---|---|
| Bubble Sort | O(n) | O(n²) | O(n²) | O(1) | Yes |
| Selection Sort | O(n²) | O(n²) | O(n²) | O(1) | No |
| Insertion Sort | O(n) | O(n²) | O(n²) | O(1) | Yes |
| Merge Sort | O(n log n) | O(n log n) | O(n log n) | O(n) | Yes |
| Quick Sort | O(n log n) | O(n log n) | O(n²) | O(log n) | No |
| Heap Sort | O(n log n) | O(n log n) | O(n log n) | O(1) | No |
HR Interview Questions
Q1: Why Samsung R&D?
Sample Answer: "Samsung R&D represents the perfect intersection of hardware and software innovation. Having used Samsung devices for years, I've always admired the seamless integration between their hardware and Android ecosystem. SRI-Bangalore's reputation for working on flagship products like the Galaxy S series and pioneering research in foldable technology makes it my top choice. I'm excited about contributing to products used by millions globally."
Q2: Tell me about a time you optimized code
STAR Example:
- Situation: Image processing app taking 5 seconds per frame
- Task: Reduce to real-time (<100ms)
- Action: Profiled code, moved heavy operations to C++, used NEON SIMD, implemented GPU shaders
- Result: 60fps achieved, 50x speedup, presented at internal tech talk
5 Frequently Asked Questions (FAQs)
Q1: What is the salary for freshers at Samsung R&D in 2026?
A: Samsung R&D offers ₹12-18 LPA for freshers, significantly higher than mass recruiters.
Q2: Is GSAT mandatory for Samsung placement?
A: Yes, GSAT (General Samsung Aptitude Test) is mandatory and serves as the primary screening.
Q3: What programming languages are tested?
A: C is heavily tested in GSAT. C++ and Java may be tested in interviews.
Q4: Does Samsung hire non-CS branches?
A: Yes, ECE, EEE, and IT graduates are also eligible for R&D roles.
Q5: What is the bond period at Samsung?
A: Typically 1-2 years with varying bond amounts based on training investment.
Last Updated: March 2026 Source: Samsung Careers, GSAT Pattern, Interview Experiences
Advertisement Placement