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 the following methods:

• LRUCache(capacity): Initializes the cache with a given maximum capacity.
• get(key) -> value | -1: Returns the value associated with key. If key is not found, returns -1. A successful get makes that key the most recently used.
• put(key, value): Inserts or updates the value for key. If key already exists, its value is updated, and it becomes the most recently used. If the cache exceeds capacity after insertion, the least recently used key is evicted.

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 for get and put.

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]: An integer array where counts[i] is the number of notifications sent during hour i.
• freeLimit: The total number of notifications per day that are free.
• unitPrice: The 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: A 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.