xAI Software Engineer Coding Questions

In xAI's data processing systems, we often encounter large arrays of user-generated metrics. Finding the maximum subarray sum quickly becomes essential to understand user behavior efficiently.
Problem Statement: Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.
- int max_sub_array_sum(List<int> nums): returns the maximum sum of the contiguous subarray.
Example 1:
Input: nums = [-2,1,-3,4,-1,2,1,-5,4]
Output: 6
Explanation: The contiguous subarray [4,-1,2,1] has the largest sum = 6.
Example 2:
Input: nums = [1]
Output: 1
Explanation: The contiguous subarray [1] has the largest sum = 1.
Constraints:
- 1 <= nums.length <= 3 * 10^4
- -10^4 <= nums[i] <= 10^4.

In xAI's recommendation system, we need to efficiently find the shortest path to similar items based on user interactions. This will help improve user engagement.
Problem Statement: Given a directed graph represented as an adjacency list, where each node represents an item and edges represent the relationship strength, implement a function that finds the shortest path from a start node to a target node using BFS. Return the list of nodes in the path from start to target, or an empty list if no path exists.
- List[int] bfs_shortest_path(int start, int target): returns the list of integers representing the path from start to target.
Example 1:
Input: start = 0, target = 4
Output: [0, 1, 2, 4]
Explanation: The shortest path from node 0 to 4 is through nodes 1 and 2.
Example 2:
Input: start = 0, target = 3
Output: []
Explanation: No path exists between node 0 and node 3.
Constraints:
- 1 <= start, target <= 10^4
- The graph can have up to 10^4 nodes and 2 * 10^4 edges.

For optimizing user interaction, xAI requires efficient routing through dialogue states in a conversation graph.
You have a directed graph where each node represents a dialogue state and edges represent possible transitions. Write a function to return the shortest path from the initial state to a target state.
Example method signature: def shortestPath(graph: Dict[int, List[int]], start: int, target: int) -> List[int]: returns a list of node values representing the shortest path.Example 1:
Input: graph = {0: [1, 2], 1: [3], 2: [3], 3: []}, start = 0, target = 3
Output: [0, 1, 3]
Explanation: One possible shortest path from the initial state (0) to target (3) is through state 1.Example 2:
Input: graph = {0: [1], 1: [2], 2: [3], 3: []}, start = 0, target = 2
Output: [0, 1, 2]
Explanation: This is a direct route from 0 to 2 passing through state 1.Constraints:
- 1 <= graph.length <= 1000
- Input graph is a directed acyclic graph (DAG).

In order to improve the efficiency of our AI models, xAI needs to analyze the time complexity of certain input sequences in real-time.
Given an array of integers nums, return the length of the longest increasing subsequence.
Example method signature: def lengthOfLIS(self, nums: List[int]) -> int: returns the length of the longest increasing subsequence found in nums.Example 1:
Input: nums = [10, 9, 2, 5, 3, 7, 101, 18]
Output: 4
Explanation: The longest increasing subsequence is [2, 3, 7, 101], therefore its length is 4.Example 2:
Input: nums = [0, 1, 0, 3, 2, 3]
Output: 4
Explanation: The longest increasing subsequence is [0, 1, 2, 3], therefore its length is 4.Constraints:
- 1 <= nums.length <= 2500
- -10^4 <= nums[i] <= 10^4