NVIDIA Data Engineer Interview Questions & Answers

I would capture the actual plan first, identify expensive joins, redistribution, repeated sorts, and spill, then reduce work with early filters, pre-aggregation, safe dimension deduplication, and compatible window definitions. I would rerun the same workload and verify the output grain, rows, duplicates, nulls, ordering, and window results are unchanged.

This query can become expensive because large joins may create or redistribute many rows before several window functions partition and sort the joined data. I would not start by rewriting SQL blindly. First, I would define the required output grain and inspect the actual physical plan and runtime evidence. I would compare rows and bytes scanned, join cardinality and distribution, window partition and ordering keys, frame widths, sort reuse, memory, and spill. The goal is to remove unnecessary work while preserving exactly the same output rows and window semantics.

1. What is the required final output grain, and which columns uniquely identify an output row?
2. Are duplicate dimension rows expected, or should each join key map to one dimension row?
3. Which filters are logically safe to apply before the large joins?
4. Can any fact-side aggregation happen before the joins without changing the required grain?
5. Do the window functions share the same PARTITION BY and ORDER BY keys, or do they require different orderings?
6. Is an expensive joined or sorted intermediate result reused enough downstream to justify materializing it?

I would use a baseline, diagnose, rewrite, retest, and verify sequence.

First, I establish the baseline. The logical SQL contains large fact and dimension joins followed by several window functions, but the logical query does not prove how the engine physically executes it. I capture the actual physical plan and runtime metrics and record rows and bytes scanned, join cardinality and distribution, sort nodes, memory and spill, window partition and ordering requirements, and whether sorts or redistributions are repeated.

Next, I identify the physical causes. Excessive rows entering the joins and windows increase downstream work. Duplicate dimension rows can multiply join output. Non-co-located join keys or incompatible window partitioning may require redistribution. Different window orderings can require additional sorts. Wide frames can make each window process more data than necessary. If sort or join state exceeds usable execution memory, the operator can spill intermediate data to storage, adding extra write, read, and merge work.

Then I apply only changes that preserve semantics. I push selective filters and unnecessary-column removal earlier when it is logically safe. If the final result only needs an aggregated fact grain, I pre-aggregate before the large joins rather than carrying unnecessary detail forward. If a dimension is supposed to contain one row per join key, I make that uniqueness explicit before joining, but I do not arbitrarily remove legitimate duplicates.

For the windows, I look for functions that genuinely use the same PARTITION BY and ORDER BY definition. Using the same window specification gives the optimizer an opportunity to reuse ordering work, but I verify actual sort reuse in the rewritten physical plan instead of assuming it. I also use the narrowest window frame that still matches the required calculation rather than changing the frame merely for speed.

I then evaluate physical layout. Partitioning or clustering that matches important filter, join, or window keys can reduce scans, redistribution, or sorting when the underlying engine and storage layout can exploit it. If an expensive intermediate result is reused downstream, materializing it can avoid recomputing the same joins or sorts, but that adds write cost, storage, freshness management, and cleanup, so I would not materialize a one-use result by default.

Finally, I rerun the rewritten query with the same representative workload and the same measurement boundary. I capture the actual plan again and compare the same evidence: rows and bytes scanned, join cardinality and distribution, memory and spill, window partitions and ordering, sort reuse, and any remaining redistribution. Performance is acceptable only if correctness also holds. I verify the same output grain, same row set, same duplicate behavior, same null semantics, same required ordering, and the same window partition, ordering, and frame results. A faster query that changes those results is not an optimization.

1. Define the required output grain and correctness contract before changing the query.
2. Capture the actual physical plan and runtime evidence for the existing query.
3. Measure rows and bytes scanned, join cardinality and distribution, redistributions, window partition and ordering keys, frame widths, sort reuse, memory, and spill.
4. Identify the dominant physical bottleneck instead of tuning every operator.
5. Push selective filters and column pruning earlier when semantics permit.
6. Pre-aggregate the large fact side to the required grain when that preserves the final result.
7. Deduplicate a dimension only when its contract requires one row per join key; otherwise preserve legitimate duplicates.
8. Align window specifications that genuinely share PARTITION BY and ORDER BY requirements and use only the frame required by the calculation.
9. Evaluate partitioning or clustering that can reduce scan, redistribution, or sorting for the actual workload.
10. Materialize an expensive intermediate result only when downstream reuse justifies its write, storage, freshness, and operational cost.
11. Rerun the same representative workload and capture the actual plan again.
12. Verify identical output grain, row set, duplicate behavior, null semantics, required ordering, and window results before accepting the rewrite.

The expensive parts are usually data movement, sorting, join state, and window state rather than the number of SQL lines. More rows entering a join increase CPU, memory, and network work, and duplicate dimension rows can multiply that cost. Redistribution sends records between workers and may require serialization and network transfer. Window functions can require partition-local sorting, which consumes memory and CPU. If sort or join state does not fit in usable execution memory, intermediate data may spill to storage and require extra writes, reads, and merge work. Early filtering and pre-aggregation can reduce downstream costs, but they are valid only when they preserve the required grain. Physical partitioning or clustering can help recurring workloads but adds layout-maintenance cost. Materializing an intermediate result can save repeated computation but adds writes, storage, freshness management, and cleanup.

Common mistakes are rewriting SQL before looking at the actual physical plan; assuming a logical filter proves that fewer bytes were physically scanned; carrying detailed fact rows through large joins when the final result only needs an aggregated grain; removing dimension duplicates without proving they are invalid; assuming every small dimension should be broadcast without checking actual size and worker memory; changing PARTITION BY, ORDER BY, or window frames merely to make the query faster; assuming identical window definitions guarantee physical sort reuse without checking the new plan; treating every spill as a request for more memory instead of reducing the rows or state causing it; materializing a one-use intermediate result; changing several optimization levers at once; and validating only row count instead of proving the same row set, duplicates, null semantics, ordering, and window results.

Lead with evidence rather than a list of SQL tricks. State the required output grain, show how the actual plan reveals the expensive join, redistribution, sort, memory, or spill behavior, make one defensible rewrite at a time, and finish by explaining how you prove the rewritten query returns the same result.

I would encode each string as its decimal length, followed by the original string and "#", then concatenate all parts. For decoding, I process one "#"-terminated item at a time. I find the next "#", build the decimal length prefix, and stop when that length equals the remaining payload size before the delimiter. Then I append the payload and continue. Both encoding and decoding take O(N) time, with O(k) auxiliary space for decoded-list references, excluding returned string contents.

The function has two modes. In encode mode, it receives a list of strings and combines them into one string. Each item becomes its decimal length, then the original text, then "#". In decode mode, it receives a valid encoded string and rebuilds the original list in order. The main challenge is that a payload may start with digits. For example, "212#" means length 2 and payload "12". The decoder therefore uses the next "#" as the item boundary and finds the length prefix that matches the payload size.

1. Can I assume the decode input is always a valid encoding, as stated?
2. Should duplicate strings and the original order be preserved exactly?
3. Can original strings contain digits, spaces, and symbols but never "#"?

The function is solution(mode, data). In encode mode, data is a list of at most 10,000 strings with at most 200,000 total original characters. The output is one encoded string. In decode mode, data is a valid encoded string. The output is the original list in the same order. Empty strings, duplicate strings, digit-leading strings, spaces, and symbols are allowed. Original strings cannot contain "#".

For each string s, create str(len(s)) + s + "#". Then join all encoded parts. In the example, "foo" becomes "3foo#" and "12" becomes "212#". Joining them gives "3foo#212#".

Start with result = [] and i = 0. Variable i points to the beginning of the next encoded item. Each iteration decodes exactly one "#"-terminated item and then advances i to the start of the following item.

The encoded input is "3foo#212#". First, i = 0. The next "#" is at index 4. The prefix candidate "3" makes j = 1. Since 3 = 4 - 1, data[1:4] is the payload "foo". Append "foo" and set i = 5.

Now the next "#" is at index 8. The prefix candidate "2" makes j = 6. Since 2 = 8 - 6, data[6:8] is the payload "12". Append "12" and set i = 9. This reaches the end of the encoded string, so the final result is ["foo", "12"].

Because "#" cannot appear inside an original string, the next "#" is the exact end of the current encoded item. Starting at i, read decimal prefix digits until the numeric value equals the number of payload characters between j and that delimiter. At that point, j is the correct payload start. After appending data[j:h], moving to h + 1 starts exactly at the next item.

Encoding uses join to build the encoded string. Decoding uses an iterative while loop, so it does not depend on recursion depth. For each item, find locates the next "#". A small inner loop builds the decimal length one digit at a time. When value == h - j, j is the payload start. The code appends data[j:h] and advances i to h + 1.

Let N be the total number of characters processed and k be the number of decoded strings. Encoding takes O(N) time. Decoding also takes O(N) time for the stated encoding. Each item is scanned to its next delimiter, and only its decimal length prefix is additionally examined. Since total original content is at most 200,000 characters, a length has at most 6 decimal digits. Auxiliary space is O(k) for decoded-list references, excluding the returned string contents. Important cases include an empty list, an empty string, digit-leading strings such as "12", spaces and symbols, and the maximum input size.

The key idea is to use "#" as the reliable end boundary of each encoded item because original strings cannot contain "#". Encoding is direct: write decimal length + payload + "#" for every string. During decoding, i always points to the beginning of the next item. After finding the next "#" at h, read decimal prefix digits until the parsed value equals h - j. Then j is the payload start. The invariant is that every completed iteration decodes exactly one valid item and moves i to the next item.

Let N be the total number of characters being processed and k be the number of decoded strings. Encoding takes O(N) time because the output is built from all input characters plus their short length prefixes and delimiters. Decoding takes O(N) time for the stated encoding because each item is scanned to its next "#", and only its length-prefix digits are additionally checked. A length uses at most 6 decimal digits because total original content is at most 200,000 characters. Auxiliary space is O(k) for the decoded-list references, excluding returned string contents.

A common mistake is reading every leading digit as the length. That fails for "212#", where the correct length is 2 and the payload is "12". Another mistake is treating "#" as the boundary between the length and payload instead of the end of the whole encoded item. Candidates may also advance i to the wrong position, lose empty strings such as "0#", change the original order, or claim O(1) auxiliary space even though the decoded result list grows with the number of strings.

Use "212#" to explain the important parsing detail. Reading every leading digit would incorrectly produce 212. Instead, use the next "#" as the item boundary and stop reading the decimal prefix when its numeric value exactly equals the number of payload characters remaining before that boundary.

I would use a greedy conversion for each integer. I keep the Roman value-symbol pairs in descending order, including subtractive forms such as CM, XC, and IV. For each number, I repeatedly take the largest value that fits, append its symbol, and subtract that value. I continue until the remaining value is zero, then move to the next input. This preserves input order. For n integers, the time is O(n), and auxiliary space is O(1), excluding the returned output.

The input is a list of positive integers, and every integer is at most 1000. We need to return one Roman-numeral string for each input value. The returned strings must stay in the same order as the input. The main idea is to keep all valid Roman values in descending order. For each number, we repeatedly choose the largest value that still fits. This naturally produces the standard Roman representation because the table also contains the required subtractive forms such as IV, IX, XL, XC, CD, and CM.

1. Can I assume every input value is positive and no greater than 1000, as stated?
2. Should duplicate input values remain as separate outputs in their original order?
3. Should the function return only the Roman strings, with no additional formatting?

The function receives a list called nums. Every value is positive and at most 1000. We return a list of strings. Each output string is the Roman representation of the value at the same input position. For example, [1, 4, 179] becomes ["I", "IV", "CLXXIX"].

I store the Roman value-symbol pairs in descending order: 1000→M, 900→CM, 500→D, 400→CD, 100→C, 90→XC, 50→L, 40→XL, 10→X, 9→IX, 5→V, 4→IV, and 1→I. The subtractive forms are included directly in this table. For the current integer, I always take the largest value that does not exceed the remaining amount.

For one input number, remaining starts as that number. roman_parts starts as an empty list. roman_parts stores the Roman symbols selected so far. The central invariant is that the selected symbols represent exactly the amount already removed from the original value. Therefore, the value represented by roman_parts plus remaining always equals the original integer.

For 1, the largest usable pair is 1→I. We append I and subtract 1. remaining becomes 0, so the result is "I".

For 4, the pair 4→IV is present directly. We append IV and subtract 4. remaining becomes 0, so the result is "IV".

For 179, remaining starts at 179. We take 100→C, so remaining becomes 79 and the result so far is "C". Next we take 50→L, leaving 29 and producing "CL". We take 10→X, leaving 19 and producing "CLX". We take 10→X again, leaving 9 and producing "CLXX". Finally, we take 9→IX, leaving 0 and producing "CLXXIX". The final returned list is ["I", "IV", "CLXXIX"].

The table contains every Roman token needed by the problem, including all required subtractive tokens. It is ordered from largest value to smallest. At every step, we choose the largest token that fits in remaining. Subtracting its value keeps the chosen symbols plus remaining equal to the original integer. When remaining reaches zero, the collected symbols represent the complete value in the required Roman form.

The outer loop processes nums from left to right, so output order is preserved. For each number, the code scans the fixed table in descending order. A while loop handles symbols that may be selected more than once, such as X in 179. Each selected symbol is appended to roman_parts, and its numeric value is subtracted from remaining. After the value reaches zero, join combines the symbols into one Roman string, which is appended to result.

The Roman table has only 13 fixed entries, and every input value is at most 1000. Therefore, each integer needs only a bounded amount of work, so n input integers take O(n) time. The temporary state for one conversion is also bounded under the stated maximum, so auxiliary space is O(1) when the returned output is excluded. Important cases include 1→I, 4→IV, 9→IX, 40→XL, 90→XC, 400→CD, 900→CM, and 1000→M. Duplicate input values are converted independently and remain in their original order.

The key insight is to use one descending table of valid Roman value-symbol pairs and make a greedy choice. For the current remaining value, take the largest Roman token whose numeric value still fits. Because subtractive forms such as CM, CD, XC, XL, IX, and IV are already included in their correct positions, the same rule handles both normal and subtractive notation. The invariant is that the symbols already collected represent exactly the part removed from the original integer. When remaining reaches zero, those symbols represent the full value.

Let n be the number of integers in nums. The table contains only 13 Roman value-symbol pairs, and each input integer is at most 1000. Under this stated bound, converting one integer takes a bounded amount of work. Processing all n integers therefore takes O(n) time. The conversion uses a fixed table, one remaining value, and a bounded temporary list of Roman pieces, so auxiliary space is O(1) when the returned output is excluded. The returned strings themselves use space proportional to the total Roman characters produced.

A common mistake is leaving out subtractive entries such as IV, IX, XL, XC, CD, or CM, which can produce nonstandard forms such as IIII instead of IV. Another mistake is putting the value-symbol pairs in the wrong order because the greedy method depends on trying larger values first. Candidates may also append a symbol without subtracting its value, or subtract a value without appending the matching symbol. Another mistake is changing the order of nums and therefore breaking the required output order. A final mistake is giving a complexity that ignores the stated maximum input value of 1000.

Use 179 while explaining the code: take C to leave 79, L to leave 29, X to leave 19, another X to leave 9, and IX to leave 0. This demonstrates the descending greedy rule and the subtractive entries with one short trace.

I would use a sliding window with a fixed array of 26 last-seen positions. I move the right pointer through the string and move left forward when the current character already appears inside the current window. After that update, the window contains only distinct characters. Every valid substring ending at right starts between left and right, so I add right - left + 1 to the total. This runs in O(n) time with O(1) auxiliary space.

The input is one lowercase English string. We need to count every nonempty contiguous part of that string whose characters do not repeat. Different index ranges count separately even if they contain the same text. We return only the total count. The main idea is to keep a valid range while moving from left to right. A fixed array records the most recent position of each lowercase letter. If the current character repeats inside the range, we move the left boundary just past its previous occurrence.

1. Can I rely on the stated guarantee that every character is a lowercase English letter?
2. Should equal substring text at different index ranges be counted separately, as stated in the problem?

The input is a lowercase English string with length from 1 to 100000. We count nonempty contiguous index ranges only. A range is valid when no character repeats inside it. We return one integer containing the total number of valid ranges. For the supplied example, s = "abca" returns 9.

I use two window boundaries named left and right. The current window is s[left:right + 1]. I also use last_seen, an array of 26 integers. Each position stores the most recent index where that lowercase letter appeared. A value of -1 means that letter has not appeared yet. The central invariant is that after left is updated, every character inside the current window is distinct.

Set left = 0 and total = 0. Create last_seen = [-1] * 26. Then move right from index 0 to the final index. For each character, compute its array position with ord(ch) - ord('a'). Before counting valid substrings, update left with max(left, last_seen[idx] + 1). The max is important because left must never move backward.

For s = "abca", start with left = 0, total = 0, and every last_seen entry equal to -1.

At right = 0, ch = 'a'. Its previous index is -1, so left stays 0. The valid substrings ending here are "a". We add 0 - 0 + 1 = 1. total becomes 1. Then last_seen['a'] becomes 0.

At right = 1, ch = 'b'. Its previous index is -1, so left stays 0. The valid substrings ending here are "b" and "ab". We add 1 - 0 + 1 = 2. total becomes 3. Then last_seen['b'] becomes 1.

At right = 2, ch = 'c'. Its previous index is -1, so left stays 0. The valid substrings ending here are "c", "bc", and "abc". We add 2 - 0 + 1 = 3. total becomes 6. Then last_seen['c'] becomes 2.

At right = 3, ch = 'a'. The previous 'a' is at index 0. We set left = max(0, 0 + 1) = 1. The valid substrings ending here are "a", "ca", and "bca". We add 3 - 1 + 1 = 3. total becomes 9. Then last_seen['a'] becomes 3. After the loop finishes, we return 9.

After left is updated, the window s[left:right + 1] contains distinct characters. Every substring ending at right and starting at an index from left through right is therefore valid. There are exactly right - left + 1 such substrings. Starting before left would include a repeated character that forced left forward. Each valid substring is counted exactly once at its ending index.

The Python code uses a fixed array of 26 entries because the input contains only lowercase English letters. Each character is processed once as right moves forward. Updating left, reading last_seen, updating total, and storing the current index take constant time. The total time is O(n). The last_seen array always contains exactly 26 entries, so auxiliary space is O(1). Relevant edge cases include a one-character string, all repeated characters such as "aaa", and an all-distinct lowercase string of length at most 26.

The key insight is to count valid substrings by their ending index instead of generating them. Maintain a sliding window s[left:right + 1] whose characters are all distinct. The last_seen array stores the most recent index of each lowercase English letter. When the current character was previously seen, move left to max(left, previous_index + 1). This removes the conflicting earlier occurrence without ever moving left backward. Once the window is valid, exactly right - left + 1 distinct-character substrings end at right. Adding that value for every right index counts every valid contiguous substring exactly once.

Let n be the length of the string. The right index visits each character once, and every operation inside the loop takes constant time. The time complexity is O(n). The algorithm uses a last_seen array with exactly 26 entries because the input contains only lowercase English letters. Its size does not grow with n, so the auxiliary space complexity is O(1).

A common mistake is to set left = last_seen[idx] + 1 without using max. That can move left backward when the earlier occurrence is already outside the current window and can cause overcounting. Another mistake is to count only the longest distinct substring instead of all valid index ranges. Some candidates generate every substring first, which creates unnecessary quadratic work. It is also important not to confuse a substring with a subsequence because the characters here must be contiguous. Finally, the contribution at each right index must be right - left + 1.

Explain the counting rule before writing the code: once s[left:right + 1] has all distinct characters, every start index from left through right gives one valid substring ending at right, so the contribution is exactly right - left + 1.