134 questions from 12 interviews · updated from reports 2015-2023
About
Teradata is a data and analytics company that provides database, data warehousing, and cloud analytics software for businesses. In India, it is commonly associated with technical hiring for software engineers, C/C++ developers, and other developer roles.
The roles that come up most are Software Engineer, C/C++ Developer and Developer. This covers 12 candidate interviews reported from 2015 to 2023. Most sat it at entry level (12 of 12 that recorded a level). Among the 10 that recorded either route, arrivals split between campus drives (8, 80%) and off-campus applications (2, 20%). Most questions fall under DSA and CS fundamentals.
Ans. Delete by searching for the key, then handle three cases: leaf, one child, or two children. A leaf is removed directly, and a node with one child is replaced by that child. For two children, replace its value with the inorder successor or predecessor, then delete that replacement node. Time is O(h), space O(h) recursively.
Ans. Use Floyd’s slow and fast pointer method to detect the loop, then remove it by finding the node where the cycle starts and setting the previous node’s next pointer to null. After slow and fast meet, move one pointer to head and advance both one step at a time. Time is O(n), space is O(1).
Ans. Use a binary recursion tree where each level represents one character, with two branches: exclude the character or include it in the current subset. Start at index 0 with an empty current string. When the index reaches the input length, output the current subset. This generates 2^n subsets, with O(n) recursion depth.
Ans. Magical or dunder methods are special Python methods with double underscores, such as __iter__ and __next__, that let objects work with built-in language features. A generator uses these iterator methods automatically: calling iter on it returns itself, and each next call resumes execution until yielding a value or raising StopIteration.
Ans. Microservice architecture splits a system into small, independently deployable services, each owning a specific business capability and usually its own data. Decoupling comes from clear APIs, separate databases, contracts, events, and independent scaling. Messaging queues add asynchronous communication, buffering, retries, and failure isolation, so services do not need to be available at the same time.
Ans. Use two pointers, one at the start of the string and one at the end, and compare characters while moving inward. If any pair differs, it is not a palindrome; if the pointers meet or cross, it is. This uses no extra data structure and runs in O(n) time with O(1) space.
Ans. In-built language exceptions are predefined error types provided by a language, such as null reference, type, index, value, file, or arithmetic errors. They are raised automatically by the runtime or manually when appropriate. Custom exceptions are raised by defining a new exception class, usually extending the base exception type, then throwing or raising it.
Ans. Kadane’s Algorithm finds the maximum sum of a contiguous subarray in linear time. It scans the array while keeping the best sum ending at the current position and the best sum seen overall. At each element, either extend the previous subarray or start a new one. It runs in O(n) time and O(1) space.
Ans. Use a min-heap of size K to find the Kth maximum element. Insert elements until the heap has K items, then for each remaining element, replace the heap root if the element is larger. The root is then the answer. This takes O(n log K) time and O(K) space.
Ans. Use a depth first traversal with valid lower and upper bounds for each node. A node is valid only if its value lies strictly between those bounds, then update the bounds for its left and right children. This checks the whole tree in O(n) time and O(h) recursion space.
Ans. Use backtracking to build permutations one character at a time until the current string has the same length as the input. Keep a used boolean array to mark chosen characters, or swap characters in place. The key detail is duplicates: sort first and skip repeated unused choices. Time complexity is O(n! × n).
Ans. Use two pointers to compare the current nodes of both lists, repeatedly link the smaller node to the result, and advance that list’s pointer. Keep a tail pointer for the merged list and attach the remaining nodes when one list ends. This relinks existing nodes, so time is O(n + m) and space is O(1).
Ans. Semaphore programming uses an integer synchronisation primitive to control access to shared resources among concurrent threads or processes. A wait operation decrements or blocks when unavailable, and a signal operation increments and wakes a waiter. Common use cases include mutual exclusion, limiting connection pools, producer consumer queues, and ordering events.
Ans. Use a min-heap to merge the K sorted arrays efficiently. Insert the first element of each array with its array index and element index, repeatedly extract the smallest element, and insert the next element from the same array. For total N elements, time complexity is O(N log K) and space is O(K).
Ans. A complex function pointer in C declares a variable that stores the address of a function, including its return type and parameter types. Read it from the name outward, using parentheses to bind the pointer before the function call part. For very complex cases, use typedefs to name intermediate function pointer types and improve readability.
Ans. Use centre expansion: for each index, expand outwards for odd length palindromes, and between this index and the next for even length palindromes. Each time the characters match, add that substring to a result list. This returns palindromic occurrences, including duplicates by position. Time is O(n²), plus output storage.
Ans. Set byte 12, bit 6: OR the 13th character with a mask of 1 shifted left by 6. A char array of 20 holds 160 bits, assuming 8-bit chars. If the 102nd bit is counted from 1 instead of 0, use byte 12, bit 5.
Ans. Count frequencies of each value, then remove every node whose value appears more than twice. Use a hash map in the first pass to store counts, then traverse again with a dummy head to relink only allowed nodes. This handles head deletion cleanly and runs in O(n) time with O(n) extra space.
Ans. Use Kadane’s algorithm by scanning the array once, keeping the best subarray sum ending at the current index and the best sum seen so far. At each element, either extend the previous subarray or start a new one. It uses only a few variables, so the time complexity is O(n) and space is O(1).
Ans. Use two stacks to traverse the tree level by level while alternating direction. Push the root into one stack, then process nodes from the current stack and push their children into the other stack in left-right or right-left order depending on the level. Swap stacks after each level. Time is O(n), space is O(n).
Ans. Use a frequency map: scan the array, count each element, then return the elements whose counts are odd. This works for any number of odd-occurring values and any element type that can be used as a key. The time complexity is O(n), and the extra space is O(k), where k is distinct elements.
Ans. User-level threads are managed by a user-space library, while kernel-level threads are managed and scheduled by the operating system kernel. User threads are faster to create and switch but one blocking system call can block the whole process. Kernel threads cost more but can run truly in parallel on multiple CPUs.
Ans. A Trie is a tree used to store strings by sharing common prefixes, so each path from root represents a word or prefix. Each node usually contains links to child nodes, often by character, and a flag marking end of word. Insert and search process characters one by one, taking O(L) time for string length L.
Ans. Data modelling defines how data is structured, related, constrained and stored, while a CI/CD pipeline automates building, testing and deploying software changes. Key data modelling concepts include entities, attributes, relationships, keys, normalisation and schemas. A basic pipeline runs on each commit, builds the code, runs tests, packages the artefact and deploys safely.
Ans. A class instance can be used as a dictionary key if it is hashable. By default, user-defined objects are hashable by identity, so each instance can be a distinct key. If the class defines equality with __eq__, it should also define a consistent __hash__, and the fields used for hashing should not change.
Ans. Use dynamic programming where dp[i] is the minimum number of perfect squares needed to sum to i. Initialise dp[0] to 0, then for each i from 1 to n, try every square j*j not greater than i and update dp[i] from dp[i - j*j] + 1. This takes O(n√n) time and O(n) space.
Ans. Data types affect memory allocation by telling the language how much space a value needs and how that space should be interpreted. For example, an integer, character, float, or object may require different amounts of memory. The key detail is that fixed-size types are usually allocated predictably, while dynamic types may need extra memory and runtime management.
Ans. Use an iterative 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 processes nodes level by level. The time complexity is O(n), and the space complexity is O(w), where w is the maximum width.
Ans. Start at the top right element and eliminate one row or one column at each step. If the current value is the target, return found. If it is greater, move left. If it is smaller, move down. This works because rows and columns are sorted. Time is O(rows + columns), space is O(1).
Ans. Linear regression models the relationship between input features and a continuous target as a straight line or linear combination of features. The model is fitted by choosing coefficients that minimise the error between predicted and actual values, usually using least squares. In practice this is done analytically or with gradient descent.
Ans. Traverse the tree level by level, alternating the direction of output at each level. Use a queue to process nodes in breadth-first order, record all nodes of the current level, then reverse that level when needed. Toggle the direction after each level. Time complexity is O(n), and extra space is O(w), where w is tree width.
Ans. Choose a situation where you moved code safely through review, testing, and release. Emphasise raising a pull request, linking requirements, ensuring automated tests pass, checking security and rollback plans, getting peer or senior approval, and following change control. Interviewers listen for ownership, risk awareness, communication, and respect for production stability.
Ans. Use a frequency hash map of the larger matrix and check every value in the smaller matrix against it. Count each element in the larger matrix, then for each element in the candidate subset, fail if the count is missing or zero, otherwise decrement it. This handles duplicates correctly. Time complexity is O(mn + pq), with O(mn) space.
Ans. Traverse root, left boundary, all leaves, then right boundary in reverse order. Exclude leaves from the left and right boundary steps to avoid duplicates. Use recursion or a stack for leaves, and a temporary stack/list for the right boundary reversal. Time complexity is O(n), with O(h) auxiliary space excluding output.
Ans. Use a hash map to count each character, then scan the string again and return the first character whose count is one. This preserves the original order while keeping lookup constant time. The time complexity is O(n), and the extra space is O(k), where k is the number of distinct characters.
Ans. Use two pointers: move the first pointer k nodes ahead, then move both pointers together until the first reaches the end. The second pointer is then at the kth node from the end. This uses no extra data structure, runs in O(n) time, and O(1) space. If k is too large, return null or an error.
Ans. Use recursion: if the current character is the string terminator, return 0; otherwise return 1 plus the length of the remaining string. The call stack replaces explicit variables. This needs no extra data structure, but uses recursive stack space. Time complexity is O(n) and space complexity is O(n).
Ans. The stack stores function call frames and local automatic variables, the heap stores dynamically allocated objects, and read-only segments store immutable program data such as machine code and string constants. The stack is managed automatically and grows or shrinks with calls, the heap is managed by an allocator or GC, and read-only pages are protected from writes.
Ans. Choose a work situation where the difficulty affected delivery, not a personal complaint. Emphasise that you stayed calm, listened, set clear expectations, and focused on facts and shared goals. Interviewers listen for self-control, empathy, boundaries, and whether you resolved the issue professionally without blaming or escalating unnecessarily.
Ans. Data types determine how much memory a value needs and how the runtime stores, references, and manages it. In Python, every value is an object with overhead for type and reference count, so an int uses more memory than raw machine integer. Containers like lists store references to objects, not the objects directly.
Ans. For an empty string literal, sizeof("") is 1 and strlen("") is 0. The size includes the terminating null character, while strlen counts characters before it. For a NULL pointer, sizeof(pointer) gives the pointer size, typically 4 or 8 bytes, but strlen(NULL) is undefined behaviour and may crash.
Ans. Use a dynamic array, such as a vector or ArrayList, to store the names in contiguous memory. In C, this would usually be a resizable array of char pointers allocated with malloc and grown with realloc. When capacity is full, allocate more space. Access is O(1), and append is amortised O(1).
Ans. Breadth First Search visits a graph level by level from a start node, using a queue to process nearest nodes first. Mark the start visited, enqueue it, then repeatedly dequeue a node and enqueue each unvisited neighbour. Its time complexity is O(V + E). Applications include shortest path in unweighted graphs, web crawling, and network broadcasting.
Ans. Use KMP to search the pattern in the string and keep updating a variable with the start index whenever a match is found. After the scan, that variable is the last occurrence, or -1 if no match exists. The key data structure is the LPS array. Time complexity is O(n + m).
Ans. Reverse it using recursion: write your own length function recursively, then print or build the character at length minus one before recursing on the remaining prefix. This uses the call stack instead of explicit variables. The key detail is that repeated length calculation makes it quadratic unless the length is computed once.
Ans. Traverse the list once and count nodes whose value is 1; if the count is odd, reverse the whole list, otherwise leave it unchanged. Reversing twice cancels out, so only parity matters. Use standard three pointers, previous, current and next. Time complexity is O(n), space is O(1).
Ans. I would raise a small, well-described pull request, get automated tests and checks passing, request peer review, address feedback, and merge only after approval. Then I would deploy through the agreed CI/CD pipeline, ideally to staging first, verify behaviour, release gradually if possible, and monitor logs, metrics, and errors with a rollback plan ready.
Ans. The code’s output is the characters reached or changed by the pointer operations, printed up to the first null terminator. To determine it, trace each pointer increment, dereference and assignment in order. The key detail is whether the pointer refers to a mutable char array or an immutable string literal.
Ans. malloc obtains a block from the heap allocator, records metadata such as size near it, and returns a pointer to usable memory. free expects exactly that returned pointer, uses the metadata to mark the block free, and may coalesce neighbours. Calling free(arr+1) is undefined behaviour because it is not the original allocated pointer.
Ans. I identify edge cases by defining valid input ranges, then testing boundaries, empty values, nulls, duplicates, extreme sizes, and invalid states. I handle them with explicit validations before core logic, clear error handling, and targeted tests. The key detail is to validate assumptions at system boundaries so the main logic stays simple and predictable.
Ans. Balanced binary search trees keep their height small, so search, insert and delete stay O(log n). An AVL tree does this by keeping each node’s left and right subtree heights within one. Its rotations are left rotation, right rotation, left-right rotation and right-left rotation, used after insertion or deletion.
Ans. Pick a real incident where you acted quickly, stayed calm, and protected customers over ego. Emphasise immediate escalation, clear impact assessment, rollback or fix options, and honest communication with stakeholders. Interviewers listen for ownership, judgement under pressure, no blame shifting, learning afterwards, and respect for release controls.
Ans. Use an array of 10 counters, one for each mark range, and scan the 240 marks once. For each mark, compute its bucket as 0 for mark 0, otherwise (mark - 1) / 10, then increment that counter. Finally print all ranges with counts. Time complexity is O(n), space is O(1).
Ans. Only the structure fields modified through a pointer to an array element change in the original array. Assigning a structure to another variable makes a copy, so changes to that copy do not affect the array. Pointer arithmetic selects different elements, while the arrow operator modifies the object the pointer currently addresses.
Ans. A compiler translates an entire source program into machine code or another target form before execution. An interpreter executes source code step by step at runtime. Internally, a compiler typically performs lexical analysis, parsing, semantic checks, intermediate code generation, optimisation, and final code generation, reporting errors before the program runs.
Ans. Detect the order by comparing the first and last elements, then run binary search with the comparison direction adjusted. If ascending, move right when the middle value is smaller than the target; if descending, move right when it is larger. The data structure is the array itself, and time complexity is O(log n).
Ans. Identify edge cases from the input contract, boundary values, empty data, duplicates, invalid types, overflow, ordering assumptions, and impossible states. Validate inputs before the main logic, return agreed errors or defaults, and add tests for each case. The key detail is separating validation from algorithm logic so correctness and complexity remain clear.
Ans. Hashing maps a key to an array index using a hash function, giving average constant time search, insert and delete. Common techniques include division, multiplication and universal hashing, with collision handling by chaining or open addressing. C++ STL unordered_map and unordered_set use hash tables, std::hash, buckets and usually separate chaining, with rehashing when load factor grows.
Ans. Build a demand prediction system that classifies each meal slot as low, normal, or high demand, then recommends cooking quantities. Use features such as day, meal type, menu items, attendance, holidays, weather, exams, past consumption, and past wastage. Train a classifier like random forest or gradient boosting, monitor prediction error, and retrain regularly with actual leftovers.
Ans. Start by clarifying the goal, scale, users, data, latency, availability, and constraints, then propose the simplest architecture that meets them. Define APIs, data model, storage choice, core services, caching, queues, and failure handling. The key detail is explaining trade-offs, such as consistency versus availability, rather than naming technologies blindly.
No question matches those filters. Reset filters.
Showing 60 of 134 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 5.1 rounds per experience, with a typical sequence of Online test → Technical → Technical → HR → HR. Individual interview paths can vary.
Among questions with a recorded difficulty, the mix is easy 35%, medium 61%, hard 4%.
