First off: I know my question is much more of an math problem/riddle/... than a really gaming related question, but I figured that e.g. the Math StackExchange didn't fit the question.
The Setup
In the last days I played Super Mario Kart Wii in 3-player Splitscreen with my roommates. After finishing one of the race series (we always play 8 races at a time), the question arose how close the final scores of all 12 drivers can become.
The Problem
In Super Mario Kart Wii, the 12 places in a race get awarded the following number of points:
Place | Points |
---|---|
1st | 15 |
2nd | 12 |
3rd | 10 |
4th | 8 |
5th | 7 |
6th | 6 |
7th | 5 |
8th | 4 |
9th | 3 |
10th | 2 |
11th | 1 |
12th | 0 |
So after 1 race, the minimum point difference between last and first place is 15.
And the maximum point difference is very easy to calculate even for N races as the same player can always come in 1st while another player can always come in last:
maxDiff(N) = N * 15 - N * 0 = N * 15
But how can we calculate the minimum point difference after exactly N races?
So in the intermediate races a non-optimal distribution of points is allowed if that leads to a lower minimum point difference after N races.
Note: The number of points handed out in one race is 73.
What we've done so far
Tried to bruteforce our case of N=8
: But there are (naively) 12!^8 = 2*10^69
different distributions. This can surely be simplified because the order of the 8 races doesn't matter but we did not come up with that yet.
We imagined a tactic for N = even
where we always mirror the places (so #1, #2, #3, ... in odd races become #12, #11, #10, ... in even races). For N=8
(which has an average number of points for each driver of 73*8/12 = 48.7
) we got that the driver who switches between #1 and #12 gets 60
points and the drivers in the middle of the pack (e.g. switching between #6 and #7) get 44
points. So we get:
minDiff(8 according to tactic above) = 60 - 44 = 16
which is only 1 point difference more than for N = 1
.
But we don't know whether this is the most efficient approach and we don't know how to optimally handle the case N = odd
.
Is anybody able to come up with a nice solution for this problem?