Solve four design-leaning coding problems

You are given four independent interview-style coding tasks. For each task, implement the requested function/class with clear inputs/outputs and reasonable constraints. (You do **not** need to integrate the tasks together.) ## 1) Rock–Paper–Scissors scoring with bonuses Design a small game engine that computes the score for a sequence of Rock–Paper–Scissors rounds. ### Rules - Each round has two moves: `playerMove` and `opponentMove`, each in `{R, P, S}`. - Outcome: - Win: player gets `+1` point - Tie: player gets `0` points - Loss: player gets `0` points - Bonus A (win streak): if the player wins **two or more rounds in a row**, then **each** win after the first consecutive win gets an **extra +1**. - Example: outcomes `W, W, W` yields base `1+1+1` plus streak bonus `0+1+1`. - Bonus B (break a tie): if the previous round was a **tie** and the current round is a **win**, the current round gets an **extra +1**. ### Requirements Given a list of rounds in chronological order, return: 1. The total score for the whole sequence. 2. The score earned **per round** (after bonuses). ### Input/Output - Input: `rounds = [(playerMove1, oppMove1), ..., (playerMoveN, oppMoveN)]` - Output: `(totalScore, perRoundScores)` Constraints: `1 <= N <= 2e5`. --- ## 2) LRU cache API Implement an in-memory cache with **Least Recently Used (LRU)** eviction. ### Requirements Implement a class with: - `LRUCache(capacity)` - `get(key) -> value | -1` (returns `-1` if not found) - `put(key, value)` Rules: - When the cache exceeds `capacity`, evict the **least recently used** key. - Any successful `get` makes that key the most recently used. - `put` of an existing key updates its value and makes it most recently used. - Target complexity: `O(1)` average time per operation. ### Follow-up (thread safety) Describe how you would make this cache safe under concurrent access from multiple threads (you do not need to implement concurrency primitives unless explicitly asked). --- ## 3) 24-hour notification billing with a daily free quota A notification service charges based on the number of notifications sent each hour of a day (24 hours total). ### Inputs - `counts[24]`: integer array where `counts[i]` is the number of notifications sent during hour `i`. - `freeLimit`: total number of notifications per day that are free. - `unitPrice`: cost per notification beyond the free limit. ### Billing rule - The `freeLimit` is applied **chronologically** from hour `0` to hour `23` (first-come-first-served). - For each hour, some portion of that hour’s notifications may be free until the daily `freeLimit` is exhausted. ### Output Return: 1. `totalCost` for the day. 2. `hourlyCost[24]` where `hourlyCost[i]` is the cost charged for hour `i`. Constraints: `0 <= counts[i] <= 1e9`, `0 <= freeLimit <= 1e12`, `0 <= unitPrice <= 1e6`. --- ## 4) Find channels with overlapping followers You are given a mapping from channels to their followers. ### Input - `channelToFollowers`: map/dictionary where `channelToFollowers[channel]` is a list (or set) of follower IDs. - `targetChannel`: a channel name that exists in the map. ### Task Return all **other** channels that share **at least one** follower with `targetChannel`. ### Output Return a list of channels (excluding `targetChannel`) that overlap. ### Follow-ups - How would you optimize if you need to answer many queries for different `targetChannel` values? - What is the time/space complexity of your approach? Constraints (suggested): up to `1e5` channels, total follower memberships up to `1e6`.