Nutanix SWE OA and Interviews, Level Not Reported: 9 Experiences

Shared by janebeingjane ·
Company
Nutanix
Reports
9 interview reports
Level
Unknown
Stages
OA → Onsite

Nine older Nutanix software engineering reports (2016–2020) with no hiring level given: graph-heavy coding tests and, in four, a debugging round.

At a glance

  • Process: these are all older reports. Most describe an online or on-campus coding round; the fuller 2016–2018 loops add a debugging round, face-to-face technical interviews, and design or HR rounds (05, 06, 07, 09).
  • Asked: graph questions in 6 of 9, debugging a given program in 4, concurrency in 4. The group-counting question Nutanix Sports Meet came up twice in Aug 2020 (01, 02).
  • Difficulty: candidates rarely rated it; the 2018 joint write-up said two of its three authors were selected (05).
  • Practise first: Nutanix Sports Meet, Team Tournament and Ternary Expression to Binary Tree.

Coverage: 9 Nutanix software engineering reports from Oct 2016 to Aug 2020 that never say whether the hire was an internship or a full-time role, so they stay out of the intern counts. Online coding rounds from 2019–2020 and fuller campus loops from 2016–2018, at BITS Goa, an Indian university and other campuses. All are more than three years old. The intern reports are in Nutanix intern debugging round and interviews and Nutanix U.S. SWE intern interviews.

What came up

Graph questions came up in six of the nine reports and debugging rounds in four. Concurrency ran through several of them: a mutex and a producer-consumer setup to debug in one report, several files merged into one output in another, and a race condition from a previous job in a third.

Topic Reports Last seen
Graphs 6 of 9 Aug 2020 (report date)
Debugging a given program 4 of 9 Oct 2018 (report date)
Concurrency and synchronization 4 of 9 Oct 2018 (report date)
Trees and binary search trees 4 of 9 Oct 2018 (report date)
Project and résumé discussion 3 of 9 Oct 2018 (report date)
Counting groups that reach a finish line together 2 of 9 Aug 2020 (report date)

Single reports also covered caching (LRU and LFU), dynamic programming on a grid, binary search over the answer, range maximum queries, and an MPI broadcast tree. A report can appear in more than one row.

Questions we found

All nine reports are more than three years old, so these tables describe the older loop, not a current one.

Algorithms / Data Structures

Question Reports Last seen
Runners on a one-lane road who can't pass each other: how many groups cross the finish? (Nutanix Sports Meet) 2: 01, 02 Aug 2020 (report date)
Alien dictionary: recover the letter order from a sorted word list 2: 06, 09 Aug 2018 (report date)
Team Tournament: longest prefix of fights that still allows a two-team split (named by a commenter) 1: 02 Aug 2020 (report date)
"Cargo Ports": deliver items in the given order with limits on item count and weight per trip (as described by commenters) 1: 03 Feb 2020 (report date)
Reach X from 1 by adding 1 or reversing the digits, in the fewest steps, with X up to 10^14 1: 04 Oct 2019 (report date)
Can a class be split into two groups where everyone in a group is friends with everyone else? 1: 05 Oct 2018 (report date)
Fold a carpet in half the fewest times so it fits in a box 1: 05 Oct 2018 (report date)
Nodes at distance X from the root, and nodes at distance X from any leaf 1: 05 Oct 2018 (report date)
Fewest hours for tailors with skill levels to finish a set of tasks 1: 06 Aug 2018 (report date)
The cell covered by the most runs of k open cells in a grid 1: 06 Aug 2018 (report date)
Build a BST from its level-order traversal 1: 06 Aug 2018 (report date)
LRU Cache, then LFU and other eviction policies (design round) 1: 06 Aug 2018 (report date)
Ternary Expression to Binary Tree 1: 07 Jul 2018 (report date)
Merge overlapping intervals 1: 07 Jul 2018 (report date)
Snake and ladder: fewest dice throws 1: 07 Jul 2018 (report date)
Fewest moves to park every car in its own spot using the one empty spot 1: 07 Jul 2018 (report date)
Sort about 1,000 numbers between 1 and 10 in O(n) 1: 07 Jul 2018 (report date)
How many swaps an unsorted array needs before a search finds the target, then the minimum 1: 07 Jul 2018 (report date)
Nth Fibonacci number 1: 08 Dec 2017 (report date)
Range maximum for billions of queries, faster than O(N) each 1: 08 Dec 2017 (report date)
Count stress-free and stressful scoring orders for a final score ("Winning at Sports") 1: 09 Oct 2016 (report date)
All subsets with a given sum 1: 09 Oct 2016 (report date)
How many discs fit into a well of varying widths 1: 09 Oct 2016 (report date)

Debugging and code repair

Question Reports Last seen
A C infix-to-postfix converter built on a linked-list stack 1: 05 Oct 2018 (report date)
Two C++ synchronization programs: a mutex with exception handling, and a modified producer-consumer with semaphores 1: 06 Aug 2018 (report date)
C++ code that merges lines from several files into one file (Repair Multi-Threaded File Merging with a Waiting Queue) 1: 07 Jul 2018 (report date)
Segment tree code with a mistake 1: 09 Oct 2016 (report date)

Behavioral (BQ)

Question Reports Last seen
Challenges from a previous job with multiple processors or threads 1: 05 Oct 2018 (report date)
What do you hope to learn at Nutanix, and what problems did you hit in a résumé project? 1: 05 Oct 2018 (report date)
Deep questions on résumé projects and a case study 1: 06 Aug 2018 (report date)
The project you enjoyed most, and how you used AI in it 1: 07 Jul 2018 (report date)

CS fundamentals

Question Reports Last seen
The MPI broadcast tree: how it works and the order of its steps (no code) 1: 08 Dec 2017 (report date)
Synchronize a variant of the bounded-buffer problem 1: 09 Oct 2016 (report date)

9 candidate timelines, 2016–2020

01: On-campus coding round with a marathon question

Report date: Aug 27, 2020 · Role: Not stated · Location: On campus · Result: Not stated

Coding round (75 minutes, 2 questions)

  1. A marathon of length M with N runners at distinct starting points and their own speeds. Nobody can pass the runner ahead; a faster runner who catches up slows to match. Count the groups that cross the finish together. The example (N = 5, M = 12) has 3 groups. The author compares it to LeetCode's Car Fleet. Practice: Nutanix Sports Meet.
  2. A reply, likely from the author, recalled only that the second question seemed a hard graph problem.

The same group-counting question, with the same example, appears in an internship test posted the same week (entry 10 in the intern roundup). This post doesn't say which hiring it was for.


02: On-campus coding round posted as screenshots only

Report date: Aug 26, 2020 · Role: Not stated · Location: On campus · Result: Not stated

Coding round

  1. The post has only screenshots. A commenter named the first question "Nutanix Sports Meet". Practice: Nutanix Sports Meet.
  2. The same commenter named the second "Team Tournament" and described it as checking, fight by fight, whether two teams are still possible. Practice: Team Tournament.

03: "Cargo Ports" online assessment

Report date: Feb 14, 2020 · Role: Not stated · Location: Not stated · Result: Not stated

Online assessment

  1. A problem titled "Cargo Ports", posted as screenshots. From the comments: items must be delivered in the order given, and each trip has limits on how many items and how much weight it can carry. One commenter called it the summer intern OA and asked for its other questions; the author didn't answer.

04: University round with a digit-reversal question

Report date: Oct 31, 2019 · Role: Not stated · Location: India · Result: Not stated

University round (1.5 hours, 2 questions)

  1. Reach a number X from 1, where each step either adds 1 or reverses the digits. One sample answer was 16 (count up to 14, reverse to 41, then add 1). X goes up to 10^14, which the author says makes a plain DP tricky.
  2. A second question shared only as a screenshot; commenters called it "Peaceful group".

05: Joint write-up from three candidates of one 2018 drive

Report date: Oct 24, 2018 · Role: Not stated · Location: Not stated · Result: Two of the three selected

Coding round (HackerRank, 60 minutes)

  1. Given mutual friendships (not transitive), can the class be split into two groups where everyone in a group is friends with everyone else in it? A one-person group is fine.
  2. Fold an a × b carpet in half, along either side, as few times as possible so it fits in a c × d box; rotating is free. For a 6 × 10 box and an 8 × 12 carpet, one fold is enough.

Passing at least 7 of 8 tests on the carpet question was the cutoff, and nobody passed every test on the first. Five moved on.

Debugging round (on paper, 50 minutes)

  1. A 90–100 line C program converting infix to postfix with a linked-list stack. The bugs the write-up lists include push and pop working on the wrong end without allocating or freeing nodes, an uninitialized head, a missing index increment when writing output, no empty-stack check before reading the top, swapped arguments in the precedence function, and a missing string terminator.

Three moved on.

Interview (45 minutes, the same question for all three)

  1. The tree arrives as rows of 0s and 1s for a complete binary tree. Find every node at distance X from the root, and every node at distance X from some leaf.
  2. Candidate 1 first talked about a past job and a race condition in which malloc held a lock while a signal handler tried to take the same lock. On the tree question, they moved from slow ideas to an index formula for a leaf's ancestor, and were then asked not to revisit an ancestor already found from another leaf. They ran out of time while coding. Selected.
  3. Candidate 2 wrote pseudocode with BFS for the first part and DFS for the second, was asked to optimize, then talked about what they hoped to learn at Nutanix and a problem from a résumé project. Selected.
  4. Candidate 3 coded the first part in Python, solved the second but struggled to code it, and was stopped after about 45–50 minutes. Not selected.

06: BITS Goa campus placement with a design round on LRU

Report date: Aug 10, 2018 · Role: Software engineer (campus placement) · Location: BITS Goa; offer in Bangalore · Result: Offer

Online test (HackerRank, 1 hour)

  1. Tailors with skill levels and tasks with difficulty levels; a tailor can take a task at or below their skill, and each task takes one hour. Find the fewest hours to finish everything. The author binary-searched over the answer.
  2. A grid of open and blocked cells and a number k. Look at every horizontal or vertical run of at least k open cells; find the largest number of runs that overlap at one cell.

One full solution plus at least half the tests on the other got 14 people shortlisted.

Debugging round

  1. Two C++ programs on OS synchronization: a mutex with exception handling, and a slightly changed producer-consumer using semaphores. Only logic errors counted. The author found 4 of 6 and 4 of 4, and was later told the score was among the best.

Technical round (stopwatch running)

  1. Build a BST from its level-order traversal, in pseudocode; a small hint helped.
  2. The alien dictionary: find the order of letters from a sorted word list. Solved quickly.

Résumé round (40–45 minutes)

  1. An engineer with about 23 years of experience asked detailed questions on projects and a case study, with some HR questions, aiming to see which team would fit.

Design round

  1. The interviewer first went over the author's debugging answers. Then: implement an LRU Cache with a suitable data structure, name other caching policies (the author offered LFU), and compare them, including pros, cons, and tweaks.

The author was one of three people selected.


07: Drive that ended in three full-time offers and one internship

Report date: Jul 22, 2018 · Role: Not stated (software engineering) · Location: Not stated · Result: Not stated

Round 1 (HackerRank, 1 hour)

  1. Merge overlapping intervals.
  2. Snake and ladder: the fewest dice throws to finish.

Fourteen moved on.

Debugging round

  1. C++ code that merges lines from several files into one file. The author found 6 errors, including no mutex to keep other writers out while one writes to the combined file, and plain mistakes such as a function called with the wrong number of arguments. Closest practice: Repair Multi-Threaded File Merging with a Waiting Queue.

Nine moved on.

Face-to-face technical round 1

  1. Turn a ternary expression into a binary tree, then explain how the code handles some edge cases. Practice: Ternary Expression to Binary Tree.
  2. A parking lot with a single free spot and every car in the wrong place: move one car at a time using the empty spot, and find the fewest moves.
  3. The project the author enjoyed most, and how AI was used in it.
  4. Sort about 1,000 numbers that are all between 1 and 10. The first answer was O(n log n); the interviewer wanted O(n), and a counting approach worked.

Six moved on.

Face-to-face technical round 2

  1. Given an unsorted array and a target, count the swaps needed for the search to find the target's correct position, in 30 minutes. The author finished in 20, then was asked for the fewest possible swaps and didn't get it in the remaining 10.

The drive ended with three full-time offers and one internship, without saying which the author received.


08: Three questions in one round

Report date: Dec 29, 2017 · Role: Not stated · Location: Not stated · Result: Not stated

Round 1

  1. The nth Fibonacci number.
  2. Explain the MPI broadcast tree: how it works and the order of its steps, with no code.
  3. An array of billions of numbers and billions of queries, each a start and end index: return the maximum in between, faster than O(N) per query.

09: Campus drive that ended with "Welcome to Nutanix"

Report date: Oct 24, 2016 · Role: Not stated (software engineering) · Location: On campus · Result: Offer

Round 1: coding (HackerRank, 1.5 hours)

  1. "Winning at Sports": for a final score you won, count the scoring orders that give a stress-free win and a stressful win, and print both counts.
  2. The alien dictionary: find the letter order from a sorted list of words.

Sixteen moved on.

Round 2: knockout debugging (printed paper)

  1. Segment tree code with a mistake: find it and write the fixed code. Half the group, 8 of 16, was cut here.

Round 3: face-to-face

  1. Find every subset of an array that adds up to X.
  2. A well of varying widths from top to bottom and a series of discs: each disc falls until it hits a level narrower than itself. Count the discs that fit before the well is full; the author preprocessed the widths for an O(m + n) answer.

Round 4: face-to-face

  1. Synchronize a variant of the bounded-buffer problem.

Round 5: HR

  1. A few basic questions and a talk about Nutanix's culture, ending with a welcome to the company.

Patterns across the reports

  1. Debugging rounds, often with concurrent code. Four reports include a debugging round (05, 06, 07, 09). Two of those programs were about synchronization: a mutex and a producer-consumer (06), and several files merged into one output (07). Concurrency also came up outside the debugging round: a bounded-buffer synchronization question in an interview (09) and a race-condition story from a candidate's previous job (05).

  2. Apparently the same Aug 2020 test, posted more than once. Entries 01 and 02 were posted a day apart with the same group-counting question, and a commenter on entry 02 names the same second question as the internship test in the intern roundup. Neither post says what kind of hire it was for.

  3. The alien dictionary appeared twice. It came up in a coding round reported in 2016 (09) and a technical interview reported in 2018 (06).

Common questions

What did Nutanix ask when the level wasn't stated?

Mostly graph and grid problems in the coding rounds (6 of 9), and in the fuller loops a debugging round on C or C++ code: an infix-to-postfix converter (05), synchronization programs (06), a multi-file merger (07) and a segment tree (09).

Keep practicing

Sources: Anywhere useful interview info can be found.

0 total reactions. Your reactions: none.

Comments

0

No comments yet — be the first to share what you know.