Implement array merge, round-robin scheduler, and trading simulator

You are given three independent coding prompts. For each prompt, clearly define your function/class interfaces, handle edge cases, and analyze time/space complexity.

1) Merge sorted arrays in-place

Given two non-decreasing integer arrays:

• nums1 of length m + n , where the first m elements are valid and the last n elements are placeholders.
• nums2 of length n .

Merge nums2 into nums1 so that nums1 becomes a single sorted array.

Inputs

• nums1: int[] , m: int
• nums2: int[] , n: int

Output

• Modify nums1 in-place.

Constraints (typical interview scale)

• 0 ≤ m, n ≤ 2e5
• Values fit in 32-bit signed integer.

Follow-up

• How would you merge three sorted arrays ( A , B , C ) into one sorted array?
• How would you merge them while also removing duplicates (i.e., output strictly increasing values)?

2) Implement a round-robin task scheduler

Implement a round-robin CPU/task scheduler with a fixed time quantum q.

Each task has:

• id (string/int)
• arrivalTime (non-negative integer)
• burstTime (positive integer total runtime required)

Scheduling rules:

1. Tasks enter the ready queue at their arrivalTime .
2. The scheduler repeatedly takes the next task from the head of the queue and runs it for min(q, remainingTime) .
3. If the task finishes, it leaves the system.
4. If not finished, it goes to the back of the queue.
5. Tasks that arrive while another task is running should be enqueued as soon as they arrive (but do not preempt the current time slice).

Output Return the execution trace as a list of segments like:

• (taskId, startTime, endTime)

Include idle time segments if the CPU is idle.

3) Simulate a simplified stock trading system

Design and implement a simplified in-memory trading simulator that processes a time-ordered stream of events.

Each event is one of:

• DEPOSIT amount
• BUY symbol qty price
• SELL symbol qty price

Rules:

• Start with zero cash and zero positions.
• A BUY decreases cash by qty * price and increases position for symbol by qty .
• A SELL increases cash by qty * price and decreases position by qty .
• Reject any BUY that would make cash negative.
• Reject any SELL that would make the position for that symbol negative.

Output After processing all events, return:

• final cash balance
• final positions per symbol
• list of rejected events (or their indices)

Follow-ups (optional, if time allows)

• Add average cost basis per symbol.
• Add realized P&L using FIFO or average cost.