Rippling Interview Questions

Rippling wants to implement a social feed where employees can post updates and follow each other, showcasing dynamic interaction and engagement among employees.
Problem statement: Design a simple social feed system where each employee can post updates and view a timeline of posts from employees they follow. The feed should support posting updates, and retrieving the latest posts from followed accounts up to a given limit.
- Class: SocialFeed
- Method: post(employeeId: int, message: str) -> void - allows an employee to post an update.
- Method: follow(followerId: int, followeeId: int) -> void - allows a follower to follow an employee.
- Method: getFeed(employeeId: int, limit: int) -> List[str] - returns the latest posts from followed employees, limited by the number specified.Example 1:
Input: post(1, 'Hello World!')
Input: follow(2, 1)
Input: getFeed(2, 1)
Output: ['Hello World!']
Explanation: Employee 2 follows employee 1 and sees their post.Example 2:
Input: post(1, 'Good Morning!')
Input: getFeed(2, 2)
Output: ['Hello World!', 'Good Morning!']
Explanation: The feed now contains two posts from employee 1.Constraints:
- 1 ≤ employeeId ≤ 10^4
- 1 ≤ message.length ≤ 140

Rippling needs a robust cache system to manage API requests for retrieving previously accessed employee benefits efficiently.
Problem statement: Implement an LRU (Least Recently Used) cache that supports the following operations: get(key: int) -> int (returns the value if the key exists, otherwise -1) and put(key: int, value: int) -> void (updates or adds the key/value pair). When the cache reaches its capacity, it should invalidate the least recently used item.
- Class: LRUCache
- Method: get(key: int) -> int - returns the value or -1 if not found.
- Method: put(key: int, value: int) -> void - adds or updates the cache.Example 1:
Input: put(1, 1)
Input: put(2, 2)
Input: get(1)
Output: 1
Explanation: Cache has key 1 with value 1.Example 2:
Input: put(3, 3)
Input: get(2)
Output: -1
Explanation: Key 2 was evicted when key 3 was added, as the capacity limitation was reached.Constraints:
- 1 ≤ capacity ≤ 3000

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 processes a large number of transactions, and we need an efficient way to cache recently accessed transaction data to improve retrieval times. Implement a Least Recently Used (LRU) cache that allows storing a limited number of transactions and supports getting and setting transaction data.
- Method signatures:
- def __init__(self, capacity: int) — Initialize the cache with a given capacity.
- def get(self, key: int) -> int — Retrieve the value for a given key if it exists, otherwise return -1.
- def put(self, key: int, value: int) -> None — Store the value for a key in the cache, evicting the least recently used item if necessary.Example 1:
Input: cache = LRUCache(2);
cache.put(1, 1);
cache.put(2, 2);
cache.get(1);
Output: 1
Explanation: The cache returns the value for key 1. The cache now contains [1, 2] as recently accessed items.Example 2:
Input: cache.put(3, 3);
cache.get(2);
Output: -1
Explanation: The key 2 was evicted when key 3 was added to the full cache.Constraints:
- 1 <= capacity <= 3000
- 0 <= key, value <= 10^4

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