Rippling Mobile Engineer Interview Questions

To improve performance and reduce latency, Rippling needs a mechanism to cache frequently accessed API responses while ensuring the least recently used data is evicted when the cache reaches capacity.
Implement a class LRUCache with the following methods:
- LRUCache(int capacity) initializes the LRU cache with a positive size capacity.
- int get(int key) returns the value of the key if the key exists, otherwise returns -1.
- void put(int key, int value) updates or inserts the value if the key is not already present. When the cache reaches its capacity, it should invalidate the least recently used item before inserting a new item.Example 1:
Input: LRUCache cache = new LRUCache(2); cache.put(1, 1); cache.put(2, 2); cache.get(1); // returns 1
Output: 1
Explanation: The cache has the key 1.Example 2:
Input: cache.put(3, 3); // evicts key 2
Output: cache.get(2); // returns -1 (not found)Constraints:
- capacity will be a positive integer.
- The total number of calls to get and put will not exceed 10^4.

To enhance the user experience, Rippling needs an efficient method to fetch and display notifications for users in real-time, balancing between performance and battery usage.
Given a string notifications representing the incoming notifications and an integer k, return the maximum number of distinct notifications that can be obtained in any sliding window of size k.Example 1:
Input: notifications = "abcabcbb", k = 3
Output: 3
Explanation: The distinct notifications in the window can be abc.Example 2:
Input: notifications = "aabbcc", k = 2
Output: 2
Explanation: The distinct notifications in the window can be ab, bc, or ca.Constraints:
- 1 <= notifications.length <= 10^5
- 1 <= k <= 10^5
- notifications consists of lowercase English letters.

Rippling needs an efficient system that can schedule and execute background tasks, such as fetching updates or syncing data, without impacting user experience or device resources.
Design a class TaskScheduler with the following methods:
- void scheduleTask(Task task) to schedule a new background task.
- void executeTasks() to run any scheduled tasks while ensuring they do not exceed resource limits.
- List<Task> getPendingTasks() to retrieve tasks waiting for execution.Example 1:
Input: Task task = new Task(); taskScheduler.scheduleTask(task);
Output: task will be executed based on system resource availability Example 2:
Input: List<Task> pendingTasks = taskScheduler.getPendingTasks();
Output: List of all tasks not yet executed Constraints:
- `Tasks may vary in size and complexity and must each include metadata for execution priority and resource requirements.

Rippling demands a robust system that allows mobile users to work offline and sync their actions with the server when they regain connectivity, ensuring data integrity and a seamless user experience.
Design a class SyncEngine with the following methods:
- void sync(Data data) to upload changes from the device to the server.
- Data fetch() to download data from the server when online.
- void saveLocally(Data data) to save data changes locally when offline.Example 1:
Input: Data data = new Data(); syncEngine.sync(data);
Output: data will be uploaded when the device is back online Example 2:
Input: Data data = syncEngine.fetch();
Output: fetch returns the latest data from the server Constraints:
- Data can represent various user actions and changes due to network unavailability.