Algorithm for percentage without knowing total number

Question

Suppose there are n lines for a hotline.

Whenever a customer calls the hotline, the call is forwarded to one of the n lines. And I want to assign percentage of calling to each of the n lines. Suppose there are two lines and one line is assigned 60% and other is 40%, the total number of calls is 10 so the first line would receive 6 calls and second will get 4 calls.

I know the percentage of calling to each line in advance but the problem is that I don't know the number of calls that would be received in a day.

How can I distribute the number of calls without knowing the total calls?

Answer 1

Do some bookkeeping about the already taken calls and calculate their distribution over the n lines. This gives you n percentage values (your already achieved distribution), which can be compared to the n percentages you want to achieve. Whenever a new call comes in, assign that call to the line with the highest deviation from the target value (note that as long as you don't hit the given distribution exactly, there is always a line which has too few calls so far, when compared to the target distribution).

For example: after assigning the first call to line 1:

 total calls line1      total calls line2    perc.line 1    perc. line 2
 1                      0                    100%             0% 
                                             *above 60%      *below 40% <- next call to 2
 1                      1                    50%             50% 
                                             * below 60%:    *above40% next to line1
 2                      1                    66%             33%
                                             *above 60%      *below 40% <- next to line 2
 2                      2                    50%             50% 
                                             * below 60%:    *above40% next to line1
 3                      2                    60%             40% 
                                             * both hit the mark: next call arbitrary
 4                      2                    66%             33%
                                             *above 60%      *below 40% <- next to line 2
 4                      3                    57.1%             42.85%
                                             *below 60%      *above 40% <- next to line 1

...

EDIT: This approach could be further improved by not using the absolute difference, but choosing the line which minimizes the sum-of-squares of all deviations. That would also give you a better result in case you reach the target values exactly.

Answer 2

• Let's suppose the number of workers is less than 100
• Create an array of workers with a capacity of 100
• Put in that array a worker a number of times equal to the percentage of calls he should get, for example if worker1 should get 30% of all calls, then put him in positions 0 to 29 of the array.
• At the end every position of the array should be used, and workers should appear in the array as many times as the percentage of calls they should get.
• In a loop, generate a random number between 0 and 99, and assign the incoming call to the worker in that position of the array. If worker is busy, repeat.
• That way, out of sheer probability, the calls will be distributed as desired
• In my example, worker1 has a 30/100 chance of getting chosen at any given iteration.

Answer 3

I agree with @DocBrown's solution. Placing it into an algorithm form:

for each incoming call:
    sort lines ascending by delta* (see footnote below)

    // first element in array gets the call 
    increase number of calls for first element by 1

• Delta is determined by the actual percentage minus the expected percentage of a line. In this way, those with the biggest negative delta are the ones which most require a call to conform with the expected percentage.

  For example, in the case in which expected percentages for lines 1 and 2 are respectively 60% and 40%, and their actual percentages are 50% and 50%, you'd see the ordering line 1 followed by line 2, since -10% is less than 10%. Hence line 1 would get the call.

  I highly recommend using insertion sort since it performs best when the array is already mostly sorted.

Also, as a minor optimization, if you keep track of the total number of calls thus far, rather than having to calculate the actual percentage of each line, you can simply calculate the total number of calls for that line minus the expected percentage for that line times the total number of calls (delta = t_i - p_i*T). In this case the delta is simply the negative number of calls to achieve the expected percentage.

I hope that clarifies any other doubts.

Answer 4

Assumptions as OP stated

1. The number of lines, n, is known and;
2. The % of each line is known

Algorithm Design

1. Define each line by its %

2. Sort each line by its position away from 0 defined as (current % of workers - assigned % of workers) or by random assignation if all lines = 0

3. Forward each call to largest line away from 0

Example: 3 lines with a % of 20, 30 and 50 respectively. At point x in time 1 person calls and since every line is 0 away from 0, it gets randomly assigned - say to line 2 which should hold 30% of all calls. Since line 2 should be holding 30% of all calls and now holds 100% of all calls, its position from 0 increases. The next caller would now be assigned to either line 1 or line 3 etc until equilibrium (0) and thus the loop repeats itself.

Answer 5

This is a naive solution and assumes nothing but would allow percentage based distribution. This solution could be improved upon in a lot of ways but this is the gist of it. I'm not sure if this is what you're looking for but it would give you true distribution.

psuedo code...

int running_total_of_calls = 0

//This is hard coded for clarity. You'd most likely want to dynamically populate this array depending and probably distribute the work by alternating workers. Notice how "worker1" appears 6 out of 10 times in the array.
string[] worker = new string[10]
workers[0] = "worker1"
workers[1] = "worker1"
workers[2] = "worker1"
workers[3] = "worker1"
workers[4] = "worker1"
workers[5] = "worker1"
workers[6] = "worker2"
workers[7] = "worker2"
workers[8] = "worker2"
workers[9] = "worker2"

while(1) //run forever
    //This is where the distribution occurs. 
    //first iteration: 0 modulus 10 = 0. 
    //second: 1 modulus 10 = 1
    //third: 2 modulus 10 = 2
    //...
    //10th: 10 modulus 10 = 0
    //11th: 11 modulus 10 = 1 
    //12th: 12 modulus 10 = 2
    //...
    int assigned_number = running_total_of_calls % workers.Count //count of workers array
    string assigned_worker = workers[assigned_number]
    do_work(assigned_worker)
    running_total_of_calls = ++running_total_of_calls