Interview experience
Samsung interview experiences covering Online Coding Assessment, Technical Interview (1-2 rounds), HR Round. Round-wise notes, common questions, and what candidates report clears each stage.
Explore: Interview experience · HR interview questions · Overview · Placement papers · Preparation guide
Samsung R&D Institute India runs large campus and off-campus drives with a strict, hidden-test-case coding assessment followed by CS-fundamentals technical rounds - not a Korea-style GSAT process.
Interview experience
Samsung interview experiences covering Online Coding Assessment, Technical Interview (1-2 rounds), HR Round. Round-wise notes, common questions, and what candidates report clears each stage.
HR interview questions
Samsung HR interview questions with sample answer frameworks - motivation, relocation, STAR stories, and culture-fit prompts.
| Round | Duration | What it tests |
|---|---|---|
| Online Coding Assessment | 2-3 hrs | 1-3 DSA problems, all/most hidden test cases must pass; sometimes + technical MCQs |
| Technical Interview (1-2 rounds) | 45-60 min each | DSA (explained verbally), OS, DBMS, OOP, networking, C/C++, projects |
| HR Round | 20-30 min | Fit, motivation, occasionally a puzzle; usually lighter than the technical rounds |
These answers are compiled from public candidate reports for Samsung R&D Institute India (SRI-B, SRI-N, SRI-D) and prep guides, not from an official Samsung notice, and drives differ. The instruction screen of your own test is the final word.
| Question | Answer |
|---|---|
| How many questions and how long? | Most reports from 2018 to 2025 describe one problem in 3 hours. Some older SRI-B campus tests had 3 easier problems in 70-90 minutes, and FACE Prep describes 1-3 problems in 90 minutes to 2 hours, so check your invite. |
| Do all test cases have to pass? | Yes, on most reports. Candidates describe 10 or 50 hidden test cases that must all pass (one SRI-D candidate wrote that 49 of 50 was not enough), with submissions capped at 5 or 10. FACE Prep says partial credit per test case, which conflicts with these first-hand reports. |
| Does it have negative marking? | No. The coding test is scored on test cases passed, and FACE Prep confirms there is no negative marking. Wrong submissions still count against the submission cap. |
| Can I use STL or Java Collections? | Often not. A 2021 SRI-D report and GfG’s SWC page say STL and Collections were banned and you build queues and stacks with arrays; a 2019 Bangalore report says STL was allowed. Assume no library and practise both ways. |
| What is the cutoff? | No test cutoff beyond passing the cases. Eligibility is set per drive: SRI-B 2021 asked for 7.0 CGPA with no active backlogs, SRI-D 2024 asked for above 7 CGPA plus 60% in 10th and 12th, and FACE Prep cites 60% or 6.0 for some notices. |
| Which platform is it on? | Samsung’s own proctored environment. Older drives used CoCubes, some 2022 tests were proctored over a mobile video call, and some tests are held on site at the Noida centre. |
| Which languages? | C, C++ and Java are standard, and FACE Prep also lists Python. GfG’s SWC page for working professionals lists only C, C++ and Java. |
The technical rounds at all three R&D centres follow the coding test. These are questions candidates have reported on GeeksforGeeks, Glassdoor and LeetCode Discuss; they show the level and style, not a fixed list.
| Centre / role | Reported questions and topics |
|---|---|
| SRI-B (Bengaluru) software engineer | Your favourite data structure. Paging and deadlock. OOP pillars with real-world examples. Medium DSA on vectors (2021). How to scale a chat app, binary search, and how to place 3 lifts in a 12-floor building (2025). |
| SRI-N / SRI-D (Noida, Delhi) software engineer | Reverse a linked list recursively. Delete a node from a doubly linked list. A singleton class. Switch vs router, DNS in depth. AVL vs red-black tree. Design Netflix, Ola/Uber or an ATM security system. Why abstract classes are needed. |
| Coding test problems | A travelling-salesman variant with bitmask DP (SRI-D 2021). “Kim and its Refrigerators” (SRI-D 2024). Mario-style shortest path and cycle detection in a directed graph (SRI-N). Left view of a binary tree and Sum Tree (older SRI-B). |
| Intern / PPO | Sort every row of a 2D matrix. Maximum-sum subsequence with no two adjacent elements. Abstract class and inheritance, process vs thread, virtual memory, and your internship project. |
Asked across every centre: a project deep-dive, the four OOP pillars, OS basics (process vs thread, paging, deadlock), a puzzle such as cutting a cake into 8 pieces with 3 cuts, and “Why Samsung?”.
The first filter is a 2-3 hour online round, sometimes run on Samsung’s own platform (Cubes or SWE certification flows appear in candidate reports) with phone proctoring on some cycles. Expect 1-3 DSA problems (graph problems, especially cycle detection, come up often) with a hidden test suite that is stricter than most fresher assessments - 50–100+ hidden cases and ~10 submission caps are commonly reported; a near-complete solution that fails even one hidden case typically doesn’t advance. Some cycles restrict STL/Collections and require queues, stacks, or heaps from scratch; others add an initial MCQ screen (quant, logical, OS/C/Java basics) before the long coding round - confirm the rules in your drive mail.
Common questions
Full round-by-round breakdowns are on the Samsung interview experience page.
Candidates who clear the coding assessment usually face one or two technical interviews. DSA is often discussed verbally - explain your approach and complexity rather than writing full code - alongside core CS fundamentals: operating systems, DBMS, OOP concepts, computer networks, and C/C++ specifics. Interviewers also spend real time on your resume projects, so be ready to defend design choices, not just describe what you built.
Common questions
See how real candidates handled this stage on the Samsung interview experience page.
The HR round at Samsung R&D India tends to be shorter and less adversarial than the technical rounds, sometimes done in small groups. It’s still an evaluation, not a pure formality - vague or rehearsed answers can cost you even here.
Common questions
Sample answer frameworks for each of these are on the Samsung HR interview questions page.
Samsung’s Global Samsung Aptitude Test (GSAT) is a real thing, but it’s easy to conflate with the SRI hiring process. GSAT is primarily used for Samsung’s broader group-level and business/sales hiring (and heavily for hiring in Korea), covering quantitative ability, reasoning, and general aptitude in a timed format. Most software engineering candidates applying to Samsung R&D Institute India go through the coding-assessment-plus-technical-interview pipeline described above instead - if a job posting or recruiter mentions GSAT for an SRI software role, confirm directly rather than assuming it replaces the coding round.
Samsung PRISM pairs students (typically final-year or pre-final-year, CGPA 7+) with Samsung engineers on real industry-academia projects, and strong performers are a recognized source of full-time offers and internships at SRI Bangalore. PRISM’s own selection process is usually three stages: a coding round (arrays, trees, linked lists), a basic aptitude test, and an interview focused on personality and motivation rather than deep technical depth.
Run DFS keeping two arrays: visited, and inRecursionStack. When DFS reaches a node already marked inRecursionStack, that edge is a back edge and a cycle exists. To recover the cycle itself, keep a parent array and walk back from the current node through parents until you return to the node you hit, collecting the nodes along the way. Clear the inRecursionStack flag as each call returns, otherwise you will report false cycles across separate branches. The whole traversal is O(V + E) time and O(V) space. Kahn’s topological sort is the alternative: if it emits fewer than V nodes, the leftovers are exactly the nodes on cycles.
Dijkstra’s algorithm breaks with negative edges because it finalises a node’s distance the moment it is popped, which a later negative edge can invalidate. Use Bellman-Ford instead: initialise the source distance to 0 and all others to infinity, then relax every edge V-1 times, since any shortest path has at most V-1 edges. Run a V-th pass; if any distance still improves, the graph has a negative-weight cycle and no shortest path exists. Complexity is O(V times E) time and O(V) space. For all-pairs shortest paths with negative edges, Floyd-Warshall gives O(V cubed) and flags a negative cycle by a negative value on the diagonal.
Paging divides both logical and physical memory into fixed-size frames and pages, typically 4 KB, so a logical address splits into a page number and an offset that indexes a page table. It eliminates external fragmentation completely, but causes internal fragmentation in the last partial page, and it is invisible to the programmer. Segmentation divides memory into variable-length, logically meaningful units - code, stack, heap - so an address is a segment number plus an offset checked against that segment’s limit. It matches the program’s structure and simplifies protection and sharing per segment, but produces external fragmentation. Modern x86 systems use segmentation with paging, where each segment is itself paged.
The browser parses the URL and checks its cache, then resolves the hostname: OS cache, then the configured resolver, which walks root, TLD, and authoritative nameservers if needed. With an IP in hand it opens a TCP connection through the three-way handshake, and for HTTPS performs a TLS handshake that negotiates a cipher, validates the server certificate chain, and derives session keys. It then sends an HTTP request; the server may respond with a redirect or a 200 with HTML. The browser parses HTML into the DOM and CSS into the CSSOM, blocking on synchronous scripts, then combines them into a render tree, runs layout and paint, and fetches sub-resources - often over the same connection thanks to keep-alive or HTTP/2 multiplexing.
Disk and SSD reads happen in pages, so the cost that matters is the number of page reads, not comparisons. A B+ tree keeps hundreds of keys per node, so its height stays around three or four even for hundreds of millions of rows, meaning a lookup costs only a few I/Os, while a balanced binary tree of the same size would be roughly 27 levels deep. B+ trees also store all data pointers in the leaves and chain the leaves in a linked list, which makes range scans and ORDER BY sequential rather than random. A clustered index stores the rows themselves in that leaf order, so a table has only one; non-clustered indexes store a pointer back to the row and may need an extra lookup unless the index covers the query.
malloc allocates a raw block of bytes and returns void star, so you must cast it, compute the size yourself, and check for a NULL return; free simply releases the block. new computes the size from the type, returns a correctly typed pointer, invokes the constructor, and throws std::bad_alloc on failure rather than returning NULL; delete invokes the destructor before releasing memory. Mixing them is undefined behaviour, as is using delete on memory from new[] - that needs delete[] so every element’s destructor runs. In modern C++ you should be reaching for std::unique_ptr, std::shared_ptr, and std::vector rather than any of these directly.
Process the list one block at a time. First check that at least k nodes remain by walking k steps ahead; if not, leave the tail as is (or reverse it too, depending on the problem statement). Reverse those k nodes with the standard three-pointer iterative reversal, which leaves the block’s original head as its new tail. Connect the previous block’s tail to the new head, then recurse or loop onto the node that followed the block. Each node is visited a constant number of times, so it is O(n) time; the iterative version is O(1) space while the recursive one costs O(n/k) stack frames. Using a dummy head node avoids special-casing the first block.
Keep a second stack of minimums alongside the main stack. On push, also push the smaller of the new value and the current minimum onto the min stack; on pop, pop both. getMin then reads the top of the min stack in O(1), at the cost of O(n) extra space. The space-optimised variant uses a single stack storing an encoded value: when a new minimum arrives, push two times the value minus the current minimum, update the minimum, and decode on pop by restoring the old minimum as two times the current minimum minus the stored value. That gets O(1) space overhead but risks integer overflow, which is worth stating explicitly.
A process is an independent execution unit with its own address space, file descriptors, and OS resources; creating one is heavier. A thread shares the process’s memory and resources but has its own stack and program counter, so creation and context switch are cheaper. Use threads for parallel work inside one application (for example UI plus background sync); use separate processes for isolation and crash containment. Samsung technical reports frequently pair this with deadlock and synchronisation follow-ups.
Mutual exclusion (resource held exclusively), hold and wait (a thread holds one resource while waiting for another), no preemption (resources cannot be forcibly taken), and circular wait (a cycle of threads each waiting on the next). Prevention breaks at least one condition - for example ordering lock acquisition to avoid circular wait. Interviewers expect you to name all four, not only the word “deadlock.”
Use a circular array with front and rear indices and a size counter, or a linked list with head and tail pointers. Enqueue and dequeue should be O(1); state how you detect full vs empty (size variable or wasted slot in circular buffer). Mention stack/heap limits on Samsung’s platform - efficient memory use matters when recursion depth is restricted on backtracking problems.
Virtual functions enable runtime polymorphism: a base-class pointer calls the derived override. Example: a Shape interface with virtual double area() implemented by Circle and Rectangle in a graphics or simulation project. Without virtual dispatch, the base method would run and break extensibility - SRI interviews often ask for project-grounded OOP, not textbook definitions alone.
Yes, on most candidate reports. The SRI test is usually one problem in 3 hours with 10 or 50 hidden test cases that must all pass and a cap of 5 or 10 submissions; FACE Prep mentions partial credit per test case, which conflicts with these first-hand reports.
Often not. A 2021 SRI-D report and GfG’s SWC page say STL and Java Collections were banned, so you build queues and stacks with plain arrays; a 2019 Bangalore report says STL was allowed, so practise without libraries to be safe. There is no negative marking.
Samsung R&D Institute India (SRI-Bangalore, SRI-Noida, SRI-Delhi) typically runs 3-4 rounds: 1. Online Coding Assessment (2-3 hours) - 1-3 DSA problems where hidden test cases must pass, sometimes with technical MCQs added. 2. Technical Interview (one or two rounds, 45-60 min each) - DSA discussed verbally plus OS, DBMS, OOP, networking, and C/C++ fundamentals. 3. HR Round - fit questions and occasionally a puzzle or two, generally lighter than the technical rounds. Total timeline is usually 2-4 weeks for on-campus drives.
Coding assessments lean on arrays, strings, linked lists, trees, and graph problems (cycle detection is a recurring theme), graded against a full hidden test suite rather than the visible samples. Technical interviews add core CS fundamentals - OS, DBMS, OOP, computer networks - and a walkthrough of your resume projects. Some cycles restrict STL/Collections usage, though this varies by campus and year.
Most SRI drives run 3-4 rounds for freshers: an Online Coding Assessment, one or two Technical Interviews, and an HR round. Some cycles report an extra screening round, taking the total to 5. Exact structure varies by location (Bangalore, Noida, Delhi) and hiring season.
Usually not for SRI software roles. GSAT (Global Samsung Aptitude Test) is Samsung’s broader group-level aptitude test, used mainly for Samsung’s business/sales/corporate hiring tracks and for hiring in Korea - it is a separate pipeline from Samsung R&D Institute India’s engineering recruitment. Most SRI software engineering candidates in India go through the coding-and-technical-interview process described on this page, not GSAT, though the two can be confused since both fall under the Samsung umbrella.
Samsung PRISM is an academia-industry research internship program that pairs students with Samsung engineers on real projects, and is one of the more common feeder routes into a full-time offer at SRI Bangalore. Its own selection process is typically three stages: a coding round (arrays, trees, linked lists), a basic aptitude test, and a personality/motivation-focused interview.
Practice DSA problems until they pass every hidden test case (not just the visible samples) under a strict time limit, revise OS/DBMS/OOP/networking fundamentals since they come up in nearly every technical round, and prepare a clear, honest walkthrough of your resume projects. Since the HR round is comparatively light, weight your prep toward the coding assessment and technical interviews.
Samsung R&D / semiconductor / mobile software campus loops vary by S/W vs H/W track. Interviewers score:
Soft fail modes: mixing up Device Solutions vs Mobile software prep, or weak C fundamentals on a software OA.
SRI campus coding tests are often long and strict: some formats allow limited or no STL/collections, cap submissions, and require all hidden cases to pass. Graph, backtracking, and memory-efficient recursion show up frequently in public write-ups. Practise implementing stacks/queues yourself and keep recursion depth and auxiliary memory under control.
Good fit: You can sit with a hard DP or grid BFS for three hours without panic, you implement from primitives when STL is banned, you can draw process vs thread and a cache hierarchy on paper, and you will move to Bengaluru or Noida. You debug with prints and a notebook, not only an IDE.
Harder path: You only grind contest hards and skip writing full programs; you freeze when libraries are blocked; you cannot explain virtual functions or page tables; you treat HR as “I like Samsung phones”; you refuse both Bengaluru and Noida.
Use this as a default four-week loop before a Samsung drive. Adjust to your invite timeline.
10-day crash version: Days 1-4 timed DSA, days 5-7 resume projects + CS fundamentals, days 8-9 mock interviews out loud, day 10 HR STAR stories on the HR page.
Candidate-reported fresher/early-career packages for Samsung often cite ₹14-28 LPA (SRI software often ₹18-24). Treat forum numbers as ranges, not guarantees - confirm the written offer letter for your team and location.
Interview process details and sample questions on this site are editorially organized from public candidate reports and hiring write-ups, with round structure, prep notes, and company-specific framing added by our team. For round-by-round stories, see the Samsung interview experience page. For OA papers and coding drills, use Samsung on placementpapers.app. Coding-test quick answers and centre-wise questions draw on GeeksforGeeks interview experiences for SRI-B, SRI-N and SRI-D campus drives and the SWC test, FACE Prep’s Samsung recruitment page, Samsung Careers’ process guide, and Glassdoor and LeetCode Discuss candidate reports.
Guides often searched alongside this page: qualcomm interview questions · nvidia interview questions · intel interview questions · texas-instruments interview questions · apple interview questions · google interview questions.