Anduril Software Engineer Interview Questions

I know, it’s Anduril, but I’m lowk unemployed lmfao Wha do the technical questions generally look like, for those of you that have interviewed there? It’s for the Software Engineer, Intelligence Syste

## Problem Implement atoi or a custom ASCII string to integer converter handling signs and overflow. ## Likely LeetCode equivalent LeetCode 8 - String to Integer (atoi) ## Tags coding, strings, parsing, embedded, phone

## Problem You are given an N x M grid where each cell is labeled with a region ID (integer). A path is given as a list of adjacent cell coordinates. Determine whether the path crosses any border (i.e., moves from one region to a different region at any step). Return the list of crossing points. ```python def find_border_crossings( grid: list[list[int]], path: list[tuple[int,int]] ) -> list[tuple[tuple[int,int], tuple[int,int]]]: # Returns list of (from_cell, to_cell) pairs where region changes pass ``` **Example:** ``` grid = [ [1, 1, 2], [1, 2, 2], [3, 3, 2] ] path = [(0,0),(0,1),(0,2),(1,2)] -> [((0,1),(0,2))] # region 1 -> 2 crossing ``` ## Follow-ups 1. How would you extend this to count the total number of unique borders (edges between distinct regions) in the entire grid? 2. If the path may jump non-adjacent cells, how do you validate that the path is geometrically continuous? 3. How would you visualize the result -- what data would you return to allow rendering of crossing markers on a map? 4. What graph algorithm would you use to find all connected components of a single region across the grid?

## Problem Implement an encoder that converts non-negative integers to and from a custom alphabet of `n` symbols, effectively treating the alphabet as a base-n number system. The first symbol represents 0. ```python def encode(n: int, alphabet: str) -> str: # encode integer n using alphabet as base-len(alphabet) digits pass def decode(s: str, alphabet: str) -> int: pass ``` **Example:** ``` alphabet = "0123456789ABCDEF" # hex encode(255, alphabet) -> "FF" decode("FF", alphabet) -> 255 alphabet = "ABCDEFGHIJKLMNOP" # custom base-16 encode(255, alphabet) -> "PP" decode("PP", alphabet) -> 255 alphabet = "01" # binary encode(10, alphabet) -> "1010" ``` ## Follow-ups 1. What happens when `n = 0`? How do you handle the edge case to return the zero symbol rather than an empty string? 2. How does this relate to Base62 encoding used in URL shorteners (alphabet = 0-9 + a-z + A-Z)? 3. How would you add padding to ensure the output is always a fixed number of digits? 4. What is the maximum integer representable by a 6-character string with a 62-symbol alphabet?

## Problem You are implementing a bare-metal LED driver in C. LEDs are controlled via an 8-bit hardware register where each bit corresponds to one LED (bit 0 = LED0, bit 7 = LED7). Implement functions to set, clear, toggle, and query individual LEDs without affecting others. ```c #include <stdint.h> #include <stdbool.h> typedef struct { volatile uint8_t reg; // memory-mapped hardware register } LedController; void led_set(LedController* ctrl, uint8_t led_index); void led_clear(LedController* ctrl, uint8_t led_index); void led_toggle(LedController* ctrl, uint8_t led_index); bool led_is_on(const LedController* ctrl, uint8_t led_index); ``` **Example:** ``` // reg initially = 0x00 led_set(ctrl, 3); // reg = 0x08 led_set(ctrl, 0); // reg = 0x09 led_toggle(ctrl, 3); // reg = 0x01 led_is_on(ctrl, 3) -> false led_is_on(ctrl, 0) -> true ``` ## Follow-ups 1. Why is the register declared `volatile`, and what happens if you omit it with compiler optimizations enabled? 2. How do you atomically read-modify-write the register on a microcontroller that does not have hardware atomic instructions? 3. How would you implement a `led_set_all(pattern)` function that sets all 8 LEDs to a bitmask pattern in a single write? 4. How would you extend this driver to support a 16-bit register (e.g., two chained shift registers)?

## Problem Write a function in C that detects at runtime whether the current processor is little-endian or big-endian, and implement functions to swap the byte order of 16-bit, 32-bit, and 64-bit integers. ```c #include <stdint.h> #include <stdbool.h> bool is_little_endian(void); uint16_t bswap16(uint16_t x); uint32_t bswap32(uint32_t x); uint64_t bswap64(uint64_t x); // Convert a 32-bit value from host byte order to network byte order (big-endian) uint32_t hton32(uint32_t x); ``` **Example:** ``` // On a little-endian x86 machine: is_little_endian() -> true bswap32(0x12345678) -> 0x78563412 hton32(0x12345678) -> 0x78563412 // must swap on little-endian host // On a big-endian machine: hton32(0x12345678) -> 0x12345678 // no swap needed ``` ## Follow-ups 1. Describe the union-based trick for detecting endianness at runtime without undefined behavior. 2. Why does network protocol code (sockets) always use `htonl`/`ntohl`, and what standard defines this? 3. How do modern compilers (GCC, Clang) optimize `bswap32` -- what intrinsic or instruction do they emit? 4. What is mixed-endian (PDP-endian) and on what historical hardware did it appear?

## Problem Process surveillance footage timestamps to find gaps, overlaps, or coverage windows. ## Likely LeetCode equivalent Similar to LC 56 Merge Intervals. ## Tags coding, arrays, intervals, phone

## Problem You are given a list of employees, each with a set of skills. Assign all employees to exactly one of `k` teams such that: (1) each team has at least one employee with each required skill, (2) team sizes differ by at most 1. Determine if a valid assignment exists, and if so, return one. ```python def assign_teams( employees: list[dict], # {"id": str, "skills": set[str]} required_skills: set[str], k: int ) -> list[list[str]] | None: # list of k teams, each as list of employee IDs pass ``` **Example:** ``` employees = [ {"id": "A", "skills": {"python", "sql"}}, {"id": "B", "skills": {"java"}}, {"id": "C", "skills": {"python"}}, {"id": "D", "skills": {"sql", "java"}}, ] required_skills = {"python", "sql"}, k = 2 -> [["A", "B"], ["C", "D"]] # one valid solution ``` ## Follow-ups 1. This problem is NP-hard in the general case. What greedy heuristic would you use to get a good-enough solution quickly? 2. How does constraint satisfaction (CSP) formulation with backtracking differ from a greedy assignment? 3. What if an employee can be on multiple teams simultaneously? How does the feasibility check change? 4. How would you model this as an integer linear program (ILP) and what solver would you use?