Rippling Software Engineer Coding Questions

Rippling aims to allocate benefits to employees based on their roles and locations efficiently.
Problem statement: You have a graph representing employees as nodes and available benefits as edges with weights belonging to those employees. Determine the minimum weight (cost) required to connect all benefits (nodes) starting from a specific employee node.
- Method: minBenefitsCost(int start, List<List<int>> benefitsGraph) -> int - returns the minimum cost to connect all benefits.Example 1:
Input: start = 0, benefitsGraph = [[0, 5, 10], [5, 0, 3], [10, 3, 0]]
Output: 8
Explanation: The optimal connections give a cost of 8 (via employee 1).Example 2:
Input: start = 1, benefitsGraph = [[0, 2], [2, 0]]
Output: 2
Explanation: Only one connection is the minimum cost (from employee 1 to 0).Constraints:
- 1 ≤ benefitsGraph.length ≤ 1000
- 1 ≤ benefitsGraph[i][j] ≤ 10^4

Rippling needs a solution to determine the longest sequence of time logs that maintain a consistent productivity rate when tracking employee hours.
Problem statement: Given an array of integers representing employee productivity per hour, find the longest contiguous subarray where the average productivity does not exceed a given threshold. The method should return the length of this subarray.
- Method: longestSubarray(int[] productivity, int threshold) -> int - returns the length of the longest subarray where average productivity <= threshold.Example 1:
Input: [1, 2, 3, 4, 2, 3], threshold = 3
Output: 4
Explanation: The longest subarray with an average ≤ 3 is [1, 2, 3, 4].Example 2:
Input: [5, 1, 3, 2, 5, 4], threshold = 3
Output: 3
Explanation: The longest subarray with an average ≤ 3 is [1, 3, 2].Constraints:
- 1 ≤ productivity.length ≤ 10^6
- 1 ≤ productivity[i] ≤ 100
- 1 ≤ threshold ≤ 100

Rippling offers tax filing services where users need to determine the shortest path to reach various filing deadlines based on their transaction history. Given a directed graph of filing options and their associated costs, compute the minimum cost to reach a specified deadline.
- Function signature: def min_cost_path(graph: Dict[int, List[Tuple[int, int]]], start: int, end: int) -> intExample 1:
Input: {0: [(1, 5), (2, 10)], 1: [(3, 2)], 2: [(3, 1)], 3: []}, 0, 3
Output: 7
Explanation: The shortest path is via node 0 to 1 to 3 with a total cost of 5 + 2 = 7.Constraints:
- 1 <= len(graph) <= 1000
- Each node's neighbor list contains no more than 10 entries.

In the context of Rippling's payroll and tax compliance services, we need an efficient way to determine the overall compliance score for a given user based on their transactions and filing history.
Given a list of user transactions and their corresponding compliance values, compute the maximum compliance score that can be achieved using at most one transaction from each period.
- Function signature: def max_compliance_score(transactions: List[int]) -> intExample 1:
Input: [10, 20, 15, 25, 30]
Output: 60
Explanation: The maximum compliance score is achieved by taking transactions with values 10, 20, and 30, leading to a total of 60.Example 2:
Input: [5, 1, 2, 10]
Output: 15
Explanation: The transactions 5 and 10 yield the highest score of 15.Constraints:
- 1 <= len(transactions) <= 1000
- 1 <= transactions[i] <= 10000