Simulate document assignment to indexers

You are given a system with m parallel indexers (workers), numbered from 0 to m-1. Documents arrive over time and are placed in a processing queue. Each document, when processed by an indexer, occupies that indexer exclusively for a given processing duration.

Document assignment works as follows (assume 0-based indexing for documents):

1. Document i arrives at time queue_time[i] and requires processing_time[i] units of processing time.
2. Let base = i % m. First, try to assign the document to indexer base.
3. An indexer j is available for a document arriving at time t if its current processing (if any) completes no later than time t.
4. If indexer base is available at time queue_time[i], assign the document to indexer base.
5. Otherwise, scan indexers in increasing order of indexer number, wrapping around modulo m: (base + 1) % m, (base + 2) % m, ..., (base + m - 1) % m. Assign the document to the first indexer found that is available at queue_time[i].
6. If no indexer is available at queue_time[i], then this document is dropped and never processed.
7. Once a document i is assigned to indexer j at time queue_time[i], that indexer becomes busy until time queue_time[i] + processing_time[i].

You are given:

• An integer m — the number of indexers.
• An integer array queue_time of length n, where queue_time[i] is the time when document i is queued. The array is in strictly increasing order (i.e., queue_time[i] < queue_time[i+1]).
• An integer array processing_time of length n, where processing_time[i] is the duration needed to process document i.

Assume n = len(queue_time) = len(processing_time).

Step 1 Design an algorithm that, using the above scheduling rules, computes:

1. The total number of documents that are processed successfully (i.e., not dropped).
2. The indexer that processed the most documents. If multiple indexers are tied for the maximum number of processed documents, you may return any one of them.

Step 2 Extend your algorithm to also compute, for a given integer k (where 1 \le k \le m):

1. The set of the top k indexers that processed the largest number of documents. If there are ties, any order or any valid choice among tied indexers is acceptable.
2. The percentage of all documents (including those dropped) that were processed by these top k indexers, as a value between 0% and 100%.

You should:

• Describe the algorithm to perform the simulation and compute all required outputs.
• Aim for an efficient solution in terms of time and space complexity.

Example

Input:

• m = 3
• queue_time = [1, 2, 3, 7]
• processing_time = [5, 4, 3, 2]
• Suppose k = 2 for Step 2.

Processing simulation:

• Document 0 arrives at time 1, base = 0. All indexers are free. Assign to indexer 0, which will be busy until time 1 + 5 = 6.
• Document 1 arrives at time 2, base = 1. Indexer 1 is free. Assign to indexer 1, busy until 2 + 4 = 6.
• Document 2 arrives at time 3, base = 2. Indexer 2 is free. Assign to indexer 2, busy until 3 + 3 = 6.
• Document 3 arrives at time 7, base = 0. Indexer 0 is free (available from time 6). Assign to indexer 0, busy until 7 + 2 = 9.

All documents are successfully processed. Indexer 0 processed 2 documents; indexers 1 and 2 each processed 1 document.

Output:

• Documents processed successfully: 4
• Indexer that processed most documents: 0
• Top 2 indexers (any valid order with ties): e.g., [0, 1] or [0, 2]
• Percentage of documents processed by these 2 indexers: 75% (3 out of 4 documents)