Random pairings with equal counts - algorithm

Question

I am working on some code that will allow assessors to assess something (vague, right?). Before assessing can occur, a random sampling needs to be taken of the submitted items. That part is rather simple.
The part that is fouling me up is the requirement that each item needs to be assessed by two different assessors and that we want the final number of assessments that each assessor performs to be as evenly distributed as possible.
Example: If I have 10 items, that should come out to 20 assessments (2 assessments per item). 20 assessments divided by 4 assessors comes out to 5 assessments per assessor. Obviously the numbers won't always come out this clean (11 items would still come out to 5 per assessor, with the remaining two to get assigned on top after everyone has evened out).
Just looking for some algorithmic help here. The closest I can get ended up being more of a bell curve than I would have liked.

Answer 1

It's not difficult. Let's say you have A accessors and I items. Just run the following loop (everything is zero-based indexing):
a = 0
for 0 <= r < 2:
for 0 <= i < I:
while (assessor a is already assessing item i):
a = (a + 1) mod A
assessor a will assess item i on round r
a = (a + 1) mod A
This will simply allocate the assessors in round-robin fashion, but will skip over those cases where the same assessor would assess the same item twice.

Answer 2

For me it looks like you need to distribute 2N assessments of N items between M assessors so that every assessor will get equal his share or as close to is as possible.
There's identity:
2N = ceil(2N/M) + ceil((2N-1)/M) + ... + ceil((2N-M+1)/M)
which can be used for that purpose. ceil here is the closest non-lesser integer: ceil(2.3) = 3, ceil(4) = 4
For you example of 11 items you will have 22 = 5 + 5 + 4 + 4 + 4.
How it works? I will refer you to "Concrete mathematics" by Knuth, Patashnik & Graham, chapter 3, part 4 for explanation :)
I've coded Anttis' approach and the one described in "Concrete math":
public static void main(String[] args) {
wayOne(5, 7);
System.out.println("======");
wayTwo(5, 7);
}
private static void wayOne(int assessors, int items) {
Integer assessments[][] = new Integer[2][items];
int assessor = 0;
for (int pass = 0; pass < 2; pass++) {
for (int item = 0; item < items; item++) {
while (assessments[pass][item] != null)
assessor = (assessor + 1) % assessors;
assessments[pass][item] = assessor;
assessor = (assessor + 1) % assessors;
}
}
for (int pass = 0; pass < assessments.length; pass++) {
for (int item = 0; item < assessments[pass].length; item++)
System.out.println("Pass " + pass + " item " + item + " is assessed by " + assessments[pass][item]);
}
}
private static void wayTwo(int assessors, int items) {
Integer distribution[][] = new Integer[2][items];
int assessments = 2 * items;
int step = 0, prevBatch = 0;
while (assessments > 0) {
int batch = (int) Math.ceil(( 2.0 * items - step) / assessors);
assessments -= batch;
for (int i = prevBatch; i < batch + prevBatch; i++) {
distribution[i / items][i % items] = i % assessors;
}
prevBatch += batch;
step++;
}
for (int pass = 0; pass < distribution.length; pass++) {
for (int item = 0; item < distribution[pass].length; item++)
System.out.println("Pass " + pass + " item " + item + " is assessed by " + distribution[pass][item]);
}
}
If I'm correct, second way will give more desired output. For example, try it for 7 items and 5 assessors. Or 11 items and 4 assessors.
UPDATE After I fixed bug pointed out by Antti, two routines give same results.