Balance the sum of elements in arrays

I am given a set of elements from, say, 10 to 21, I generate arrays of the same size, where size is determined runtime.

Example of 3 generated arrays (arrays # is dynamic, where some elements can be 0s - not used):

A1 = [10, 11, 12, 13]

A2 = [14, 15, 16, 17]

A3 = [18, 19, 20, 21]

these generated arrays will be given to different processes to to do some computations on the elements. My aim is to balance the load for every process that will get an array. What I mean is:

With given example, there are

A1 = 46

A2 = 62

A3 = 78

potential iterations over elements given for each thread.

I want to rearrange initial arrays to give equal amount of work for each process, so for example:

A1 = [21, 11, 12, 13] = 57

A2 = [14, 15, 16, 17] = 62

A3 = [18, 19, 20, 10] = 67

(Not an equal distribution, but more fair than initial)

This works fine for given example, but there may be weird cases..

So, I see this as a reflection problem (due to the lack of knowledge of proper definition), where arrays should be seen with a diagonal through them, like:

10|111213

1415|1617

181920|21

And then an obvious substitution can be done..

I tried to implement like:

  if(rest == 0)
    payload_size = (upper-lower)/(processes-1);
  else
    payload_size = (upper-lower)/(processes-1) + 1;
  //printf("payload size: %d\n", payload_size);
  long payload[payload_size];
  int m = 0;
  int k = payload_size/2;
  int added = 0;  //track what been added so far (to skip over already added elements)
  int added2 = 0;  // same as 'added'
  int p = 0;
  for (i = lower; i <= upper; i=i+payload_size){
    for(j = i; j<(i+payload_size); j++){
       if(j <= upper){
         if((j-i) > k){
           if(added2 > j){
             added = j;
             payload[(j-i)] = j;
             printf("1 adding data: %d at location: %d\n", payload[(j-i)], (j-i));
           }else{
             printf("else..\n");
           }
         }else{
           if(added < upper - (m+1)){
             payload[(j-i)] = upper - (p*payload_size) - (m++);
             added2 = payload[(j-i)];
             printf("2 adding data: %d at location: %d\n", payload[(j-i)], (j-i));
           }else{
             payload[(j-i)] = j;
             printf("2.5 adding data: %d at location: %d\n", payload[(j-i)], (j-i));
           }
         }
       }else{ payload[(j-i)] = '\0'; }
    }
    p++;
    k=k/2;

    //printf("send to proc: %d\n", ((i)/payload_size)%(processes-1)+1);
  }

..but failed horribly.

You definitely can see the problem in the implementation, because it is poorly scalable, not complete, messy, badly written and so on, and on, and on, ...

So, I need help either with the implementation or with an idea of a better approach to do what I want to achieve, given the description.

P.S. I need the solution to be as 'in-liney' as possible (avoid loop nesting) - that is why I am using bunch of flags and global indexes.

I am sure there is a solution somewhere out there, but I just cannot make an appropriate Google query to find it.

Hint? I thought of using index % size_of_my_data to achieve this task..