935 questions from 101 interviews · updated from reports 2014-2024
About
Accolite Digital is a technology services company that builds software products and digital platforms for businesses. In India, it is commonly seen hiring Software Engineers, Software Development Engineers, and Software Engineer Interns who may convert to full-time roles.
The roles that come up most are Software Engineer, Software Development Engineer and Software Engineer Intern + FTE. This covers 101 candidate interviews reported from 2014 to 2024. Most sat it at entry level (82 of 100 that recorded a level), with 17 internship interviews alongside. Among the 95 that recorded either route, arrivals split between campus drives (60, 63%) and off-campus applications (35, 37%). Most questions fall under DSA and CS fundamentals.
Ans. Reverse a linked list by iterating through it and changing each node’s next pointer to point to the previous node. Keep three pointers: previous, current, and next, so you do not lose the rest of the list. At the end, previous is the new head. Time complexity is O(n), space complexity is O(1).
Ans. Print the first node visible at each depth when the tree is viewed from the left. Do a level order traversal using a queue, and for each level print the first node removed from the queue. This visits every node once, so the time complexity is O(n), with O(w) space for the queue.
Ans. Use Floyd’s cycle detection with two pointers, slow and fast, starting at the head. Move slow one node at a time and fast two nodes at a time. If they ever meet, there is a loop. If fast reaches null, there is no loop. This runs in O(n) time and O(1) space.
Ans. SQL joins combine rows from related tables using a matching condition, usually a key. INNER JOIN returns only matching rows. LEFT JOIN returns all rows from the left table plus matches from the right. RIGHT JOIN is the reverse. FULL OUTER JOIN returns all rows from both sides. CROSS JOIN returns every combination of rows.
Ans. Object-Oriented Programming models software as objects that combine data and behaviour. The main concepts are encapsulation, which hides internal state; abstraction, which exposes only needed details; inheritance, which reuses and extends existing classes; and polymorphism, which lets different objects respond to the same interface in their own way.
Ans. A process is an independent running program with its own memory space, while a thread is a smaller unit of execution within a process that shares that process’s memory. Processes are more isolated and cost more to create or switch between. Threads are lighter, but shared memory makes synchronisation and race conditions important.
Ans. An array stores elements in contiguous memory and supports fast index access, while a linked list stores elements as nodes connected by pointers and is efficient for insertions or deletions when the position is known. Arrays are usually better for searching by index and cache performance. Linked lists use extra memory for pointers.
Ans. Serialize the tree using preorder traversal and record null children with a sentinel, then deserialize by reading the values back in the same order. Use a list or stream of tokens and a recursive index or queue. Each node and null marker is processed once, so time is O(n) and space is O(n).
Ans. Work backwards from the desired array to all zeroes. If any element is odd, subtract one from each odd element and count those subtractions. If all elements are even, divide every element by two and count one step. Repeat until all values are zero. This is greedy and runs in O(n log m), where m is the maximum value.
Ans. Use two pointers, one for each array, and build a result array by repeatedly taking the smaller current element. When one array is exhausted, append the remaining elements from the other array. This keeps the result sorted. The time complexity is O(n + m) and the extra space is O(n + m).
Ans. Reverse it by walking through the list once and redirecting each node’s next pointer to the previous node. Keep three pointers: previous, current, and next, so you do not lose the remaining list. At the end, previous becomes the new head. Time is O(n), space is O(1).
Ans. ACID properties are the guarantees that make database transactions reliable: Atomicity, Consistency, Isolation and Durability. Atomicity means all or nothing, Consistency keeps valid rules, Isolation prevents concurrent transactions interfering, and Durability ensures committed changes survive crashes. They are essential for correctness in systems handling critical data.
Ans. Use two pointers: move a slow pointer one node at a time and a fast pointer two nodes at a time. When the fast pointer reaches the end, the slow pointer is at the middle. This uses no extra data structure, runs in O(n) time, and O(1) space.
Ans. An operating system manages hardware resources and provides services for programs, such as process scheduling, memory management, file systems, device access and security. The key idea is abstraction: it hides hardware details behind interfaces, while coordinating safe and efficient sharing of CPU, memory, storage and input or output devices.
Ans. Use breadth first search with a queue. Put the root in the queue, then repeatedly remove the front node, visit it, and add its left and right children if they exist. This visits nodes level by level from left to right. The time complexity is O(n), and the space complexity is O(w), where w is the maximum width.
Ans. Normalization is structuring a database into related tables to reduce duplication and avoid update, insert, and delete anomalies. It uses normal forms and keys to keep data consistent. Denormalization deliberately adds redundant data or combines tables to make reads faster, trading storage and write complexity for simpler, quicker queries.
Ans. Encapsulation is the practice of keeping an object’s data and the methods that operate on it together, while hiding internal details from outside code. The key point is controlled access: fields are usually private, and other code interacts through public methods, which helps protect invariants and reduce unintended dependencies.
Ans. Merge sort is a divide and conquer sorting algorithm that splits the array into halves, sorts each half recursively, then merges the sorted halves. The key step is merging by comparing the smallest remaining elements. It runs in O(n log n) time and usually needs O(n) extra space.
Ans. Use the Dutch National Flag algorithm with three pointers: low, mid, and high. Move 0s to the front, 2s to the end, and leave 1s in the middle by swapping in place while mid is not past high. It uses no extra data structure and runs in O(n) time with O(1) space.
Ans. Choose a real conflict where you helped move people from blame to a practical decision. Emphasise listening to both sides, clarifying the shared goal, using facts, agreeing actions, and following up. Interviewers listen for calm judgement, fairness, communication, ownership, and evidence that the relationship and outcome both improved.
Ans. Use two pointers, one on each list, and advance them one node at a time; when a pointer reaches the end, move it to the head of the other list. If the lists intersect, the pointers meet at the intersection node after equalised traversal. This uses constant extra space and runs in O(m + n) time.
Ans. The minimum platforms needed is the maximum number of trains present at the station at the same time. Sort arrival times and departure times separately, then use two pointers to sweep through them. Increase platforms on an arrival, decrease on a departure. If times are equal, treat arrival first. Time complexity is O(n log n).
Ans. Select the salary from the distinct salaries ordered descending, skip the first two rows, and return the next one. In SQL terms, use DISTINCT with ORDER BY salary DESC plus OFFSET 2 FETCH NEXT 1 ROW ONLY, or LIMIT 1 OFFSET 2. The key detail is using distinct salaries, not rows.
Ans. I would answer by defining the concept first, then explaining its purpose and one practical example or trade-off. For Computer Networks, focus on protocols and layers. For DBMS, focus on keys, normalisation, transactions and indexing. For OOPS, focus on encapsulation, inheritance, polymorphism and abstraction with real use cases.
Ans. A DBMS stores, organises and retrieves data reliably, with joins combining related tables, normalization reducing duplication, and indexing speeding up lookups. Joins match rows using keys, such as inner or outer joins. Normalization splits data into well-structured tables. Indexes use structures like B-trees to find rows faster, with extra storage and slower writes.
Ans. Merge Sort splits the array into halves, sorts each half, then merges them in order, taking O(n log n) time in all cases and O(n) extra space. Quick Sort partitions around a pivot, then sorts the two sides, averaging O(n log n) time, but degrading to O(n²) with poor pivots.
Ans. Indexing in a DBMS is a technique that speeds up data retrieval by keeping a separate, ordered structure of key values with pointers to table rows. It works like a book index, reducing full table scans. Common types are primary, secondary, clustered, non-clustered, dense, sparse, and B-tree or hash indexing.
Ans. Use a hash set to store all numbers, then start a sequence only from numbers whose previous value is not in the set. For each start, keep checking next values and track the longest range found. Finally print that range. This avoids sorting and runs in O(n) average time with O(n) extra space.
Ans. Select the smallest distinct salary that is greater than the overall minimum salary. In SQL, this is commonly done with a subquery: first find MIN(salary), then find MIN(salary) where salary is greater than that value. Using DISTINCT or this comparison matters because duplicate minimum salaries should not count as second minimum.
Ans. Work backwards from the desired array to all zeros and count operations. If any element is odd, decrement each odd element by one and count each decrement. If all elements are even, divide the whole array by two and count one doubling step. Repeat until every element is zero. This gives the minimum steps in O(n log M).
Ans. Use two pointers from both ends, keeping the maximum height seen on the left and right. Move the side with the smaller current height, because trapped water there is limited by that side’s maximum. Add max minus current height when positive. This uses constant space and runs in O(n) time.
Ans. Convert both hands to degrees from 12 o’clock. For time h:m:s, the hour hand angle is 30h + 0.5m + s/120, using h modulo 12. The second hand angle is 6s. Take the absolute difference, then if it is over 180 degrees, subtract it from 360 to get the smaller angle.
Ans. Use the Dutch National Flag algorithm with three pointers: low, mid and high. Scan once: put 0s before low, leave 1s in the middle, and put 2s after high by swapping. This sorts in place with no extra data structure, taking O(n) time and O(1) space.
Ans. Common Git commands include clone to copy a repository, status to inspect changes, add to stage files, commit to save a snapshot, pull to fetch and merge remote changes, push to upload commits, branch to manage branches, checkout or switch to move between them, merge to combine work, and log to view history.
Ans. Use two stacks, one for incoming elements and one for outgoing elements. Enqueue pushes onto the incoming stack. Dequeue pops from the outgoing stack; if it is empty, move all elements from incoming to outgoing first. This reverses order correctly. Each operation is amortised O(1), with O(n) extra space.
Ans. Paging is a memory management technique where a process’s virtual address space is split into fixed-size pages, and physical memory is split into same-size frames. The OS maps pages to frames using a page table, allowing non-contiguous allocation. The key benefit is avoiding external fragmentation while supporting virtual memory.
Ans. In C++, a structure and a class are almost the same, but struct members are public by default, while class members are private by default. Structs are usually used for simple data grouping, while classes are usually used when data and behaviour are encapsulated together with controlled access.
Ans. Use a hash set to track values already seen, and build a new array only with elements encountered for the first time. This preserves the original order of unique elements. The time complexity is O(n), and the extra space complexity is O(n).
Ans. A pointer is a variable that stores a memory address, while a reference is an alias for an existing object. A pointer can be null, reassigned, and used with pointer arithmetic. A reference must be initialised when declared and normally cannot be made to refer to another object later.
Ans. Swap the left and right child of every node in the binary tree. Do this with a depth first traversal: at each node, swap its children, then recurse on the left and right subtrees. The tree itself is modified in place. Time complexity is O(n), and recursion uses O(h) stack space.
Ans. Count the nodes by traversing the whole binary tree and adding one for each visited node. Use recursion: if the current node is null, return zero, otherwise return one plus the counts of the left and right subtrees. This visits every node once, so time is O(n) and space is O(h).
Ans. Recursion is a function calling itself, an array is a contiguous indexed collection, a stack is last in first out, and a queue is first in first out. Recursion needs a base case to stop. Arrays give fast index access. Stacks suit undo or call tracking. Queues suit scheduling and breadth first processing.
Ans. Use Kadane’s algorithm: scan the array once, keeping the best subarray sum ending at the current position and the best overall sum seen so far. At each element, either extend the previous subarray or start a new one. This uses only variables, runs in O(n) time, and O(1) space.
Ans. Aggregation and composition are “has-a” relationships in Java, where one class contains a reference to another object. In aggregation, the contained object can exist independently, such as a Department having Teachers. In composition, the contained object’s lifetime depends on the owner, such as a House having Rooms created and destroyed with it.
Ans. Normalization in DBMS is the process of organising data into well-structured tables to reduce redundancy and avoid insert, update and delete anomalies. Its main types are normal forms: 1NF removes repeating groups, 2NF removes partial dependency, 3NF removes transitive dependency, BCNF strengthens dependency rules, and 4NF and 5NF handle complex multivalued and join dependencies.
Ans. IPv4 uses 32-bit addresses, while IPv6 uses 128-bit addresses. IPv4 is usually written in dotted decimal form, such as 192.168.1.1, and has a limited address space. IPv6 is written in hexadecimal groups and provides a vastly larger address space, reducing the need for NAT and supporting modern internet growth.
Ans. Scan the sorted array once and, for each adjacent pair, print every integer between the previous value plus one and the current value minus one. No extra data structure is needed because the order is already sorted. The time complexity is O(n + m), where m is the number of missing values printed.
Ans. The height of a binary tree is found by taking 1 plus the maximum height of its left and right subtrees. For an empty tree, return 0. Use DFS recursively, or an explicit stack for iteration. Each node is visited once, so the time complexity is O(n) and space is O(h).
Ans. Scan the string to count each character, then scan it again and return the first character whose count is one. Use a hash map or fixed-size frequency array, depending on the character set. This keeps the order check simple and runs in O(n) time with O(k) space, where k is the number of distinct characters.
Ans. To check whether a number is an Armstrong number, count its digits, sum each digit raised to that count, and compare the sum with the original number. For example, 153 is valid because 1³ + 5³ + 3³ = 153. Process digits using division and modulo. Time complexity is O(d), space is O(1).
Ans. Pick a real team situation with tension, such as unclear ownership, missed deadlines, or conflicting opinions. Emphasise what you did to improve communication, align priorities, and support others. Interviewers listen for accountability, calm problem solving, respect for teammates, and a clear result that shows the team worked better afterwards.
Ans. Use the larger 5 litre jug and the smaller 3 litre jug. Fill the 5 litre jug, pour into the 3 litre jug, leaving 2 litres. Empty the 3 litre jug, pour the 2 litres into it, then refill the 5 litre jug and top up the 3 litre jug. Exactly 4 litres remain in the 5 litre jug.
Ans. Design it as a state machine with states like idle, selecting item, accepting payment, dispensing, returning change, and out of service. Core components are inventory, payment handling, pricing, change management, dispenser, and controller. The most important detail is making payment and inventory updates transactional so money is not taken unless dispensing succeeds.
Ans. Put one winning coin alone in one room, and put all remaining coins in the other room. The first room then gives a 100% chance if chosen. The second room has nearly half winning coins. With 50 gold and 50 silver coins, the chance is 1/2 + 1/2 × 49/99 = 74/99.
Ans. MVC separates an application into Model, View and Controller. The Model holds business data and rules, the View renders the user interface, and the Controller handles user input, calls the Model, and selects the View. The key benefit is separation of concerns, making code easier to test, change and maintain.
Ans. Model the ATM with classes such as ATM, Card, Account, Transaction, CashDispenser, Keypad, Screen, BankService and ReceiptPrinter. ATM coordinates the flow: authenticate card and PIN, choose operation, validate with BankService, update Account, then dispense cash or print receipt. Use inheritance for Transaction types and interfaces for hardware devices.
Ans. Draw one fruit from the basket labelled “apples and oranges”. Since every label is wrong, that basket contains only the fruit you drew. If it is an apple, label it apples. The basket labelled oranges cannot be oranges, so it is mixed. The remaining basket is oranges. Reverse apple and orange if needed.
Ans. A strong answer should show respect, patience and evidence. Pick a simple college, internship or project example where you suggested an improvement. Emphasise that you first tried to understand your boss’s concerns, then explained the idea with facts, benefits and risks. Interviewers listen for maturity, communication and openness to feedback.
Ans. The total number of squares is n(n + 1)(2n + 1) / 6. Count all possible square sizes: there are n² squares of size 1, (n - 1)² of size 2, and so on down to 1². So add 1² + 2² + ... + n².
Ans. Use the binomial method: count the favourable outcomes and divide by all possible outcomes. With 6 coins, total outcomes are 2^6 = 64. At least 5 heads means exactly 5 heads or exactly 6 heads. Favourable outcomes are C(6,5) + C(6,6) = 6 + 1 = 7, so the probability is 7/64.
No question matches those filters. Reset filters.
Showing 60 of 935 questions. Ranked by how often the same question came back across interviews.
A spoken interview built from these questions, scored when you finish; the feedback is yours.
Start practisingWhen you are ready, record The One: a single interview hiring teams watch, so you stop repeating first rounds.
Candidate interviews most often cover DSA (49%) and CS fundamentals (42%).
Candidate interviews show an average of 4.7 rounds per experience, with a typical sequence of Online test → Online test → Technical → Technical → HR. Individual interview paths can vary.
Among questions with a recorded difficulty, the mix is easy 48%, medium 45%, hard 7%.
