What was wrong with my suggestion? Why is it incorrect?

Here's some metaverse math trivia: Suppose your overall score is r, with total games played n. So, the total score in all your games is r*sqrt(n). What score s do you need to get in your next game for your overall score to remain the same? You really need to do this calculation.

Suppose your scores are 200, 1000, 2000 (in that order). The 200 score is dragging down your ranking. You don't want to delete it, because after you've played a large number of games, the 200 score does become valuable. That's why "temporarily drop bad scores" is needed.

My definition of a "bad score": A score is "bad" if deleting that result would improve your overall ranking. Notice that a bad score can become good as you submit more results. The formula of (total score)/(sqrt(# games)) means that you compute your average score, and then get a bonus multiplier of (sqrt(# games)). A "bad score" brings down your avergage, but increases your bonus multiplier. As you have more results, the break-even point becomes lower compared with your real average.

We are considering a feature where you can flag X scores to not be counted as part of your overall score. Where X can't be more than 1/3rd of your total scores. (Otherwise everyone would just keep their #1 score and delete the rest).

~SDC~

Then IMHO this way is better:

N - number of games
Score[i] - array with game scores, sorted in descending order
C=Max(5,N*2/3)

N (lower or equal) C - old scoring system - Score = (Sum(Score[1]..Score[N])/SQRT(N))

N (more than) C - Score = Max(Sum(Score[1]..Score[C])/SQRT(C),..,Sum(Score[1]..Score[i])/SQRT(i),..,Sum(Score[1]..Score[N])/SQRT(N))

Same result, but automatically.

Edit: That the hell with this forum?
[Message Edited]
[Message Edited]

To fsk+

Because you still may be penaltized then using system suggested by you (and you are not first with this idea, i already told that it's not perfect).

~SDC~

I see - Ellestar's proposal is equivalent to what I wrote above. The computation time for either method is O(n^2).

The idea of allowing users to flag their scores for inclusion is interesting. However, I think that the flags should be automatically placed so that the overall score is maximized.

Under Frogboy's proposal, every user will have to get out a calculator to decide which scores to flag.

What combination of scores makes the systems different? One high score and a lot of low scores?

I don't see the counter-example.

You're saying that it might be necessary to drop scores in bunches, in order to find the maximum? That seems counter-intuitive.

With the example given above: 5000, 2000, 2000.

Inlcuding all 3 scores yields 9000/sqrt(3) = 5196. We try to drop the 2000, yielding 7000/sqrt(2) = 4950. We stop, and the player has the best rating of 5196.

So, Ellestar's example of 5000, 2000, 2000 does not lead to my suggestion being suboptimal.

I think it's possbile to do a formal math proof:

If dropping some combination of scores will improve your score, then dropping the worst score will also improve your score. The optimal combination of scores to drop is always a continuous range of scores, starting with your lowest score.

That sounds intuitively right, but I may be missing something.

Well idea with flags is just insane.

To fsk+

I'm not that good at programming theory, but i suggest that O(n^2) means that 2x number of games means 4x calculations?

1) My method is better because it's always gives maximum score to a player.
2) IMHO you can calculate something like that:

That's for second case
//N=NumberOFGames-1//
PlayerScore=0;
Sum=0;
for (i=0;i(less)N;i++)
{
Sum=Sum+Score[i];
PlayerScore=Max(PlayerScore;Sum/Sqrt(i));
}

~SDC~

It's O(n * log(n)). You need to sort the scores, which takes n*log(n) time. I miscalculated the complexity. I think I made a small mistake that made my version O(n^2) instead of O(n*log(n)). I still think that both give the same final answer. I can't see a counter-example.

If you're really interested in complexity theory, here's a good starting point:

http://www.wikipedia.org/wiki/Sorting_algorithm

A good book is:

Introduction to Algorithms, Second Edition
by Thomas H. Cormen (Author), Charles E. Leiserson (Author), Ronald L. Rivest (Author), Clifford Stein (Author)

While we're on the subject of the metaverse, there really should be a feature to save scores for submission later. If your internet connection is down, or the stardock website is down, the savegame should be saved and submitted later. The user should be prompted if he wants to submit the score later.

I made a mistake - parents demanded phone, and i just hit 'submit' w/o checking
//N=NumberOFGames-1//
C=Max(4,N*2/3-1/3)
PlayerScore=0;
Sum=0;
for (i=0;i(less)N;i++)
{
Sum=Sum+Score[i];
if (i(equal or more)C)
{
PlayerScore=Max(PlayerScore;Sum/Sqrt(i));
}
}

~SDC~
[Message Edited]

Some of you guys are losing track of the other point of the metaverse -- it's supposed to be a vaguely accurate way of determining skill.

If the scores just added up, then it's purely the guy who plays the most.

The current system adds your scores together and then divides them by the square root of th enumber of games you've played. Pretty mild.

~SDC~

Hm? Our system makes the same by the way. Say, if C=(Number of games*2/3)-1, then it's that you suggested in #27. (-1 because 1st game has number 0)
~SDC~
[Message Edited]

As I pointed out in a previous thread, the way the Metaverse is currently structured, it does not accurately reflect skill. The main mechanic that breaks this is the retroactive normalization of scores.

Here's the problem:

When you retroactively adjust scores toward zero of a person who has 30 games, his overall score will obviously drop, while say the next 5 games submitted on the current version are scored normal. However, those new 5 games are still chained to the previous 30 scores that suddenly got stilted toward zero.

Now take a newbie who submits maybe 10 games with roughly the same scores as the first player. Chances are, that player is going to have a far superior score as the first player. In fact as the life cycle of this game carries on to say a year to 2 years, any newbie showing up is going to have a fairly substantial advantage over a veteran that's been playing the game a while. This is no a reflection of skill, but a reflection of newness.

This is why I advocated server side scoring with the servers handling the scoring mechanics in the following manner. Lets say that we went to 1.1. Since 1.1 is the current version, anyone submitting a 1.1 game gets a normal score. But what happens is someone submits a 1.04 game? Well that game would receive some sort of deprecation penalty since his version is an older version. Someone submitting a 1.3 game would receive even less and so on.

This accomplishes several things:

1. There would no be this silly need to manually recalculate everyone's scores
2. It is more fair to the veterans of the game
3. Makes it harder for a person to manipulate a metaverse score in transit
4. You wouldn't have this wild flakiness in scoring based on the version of the game we're using.

As it is, the submission process really needs help. It would seem to me that if you're going to put up a sumission process, that you'd at least put up a feedback window describing if your submission was successful or not. This is just good GUI design practices 101. It seems silly that you dont get feedback if your submission succeeded one way or the other.

SeanB

Edit: C must be no more then N, and so C=Min(C,N)

~SDC~

What forceinfinity is really saying is that you really need multiple ways to sort the rankings.

"Current version only"

"Tiny maps only"

"Gigantic maps only"
"Last 3 months only"

"If the scores just added up, then it's purely the guy who plays the most."

Then why not add up, with cap: 10 Best Games, or 5 Best Games, whatever.

You still lose your worst scores, but result does not depend on # of games played.

But you are not stuck with old scores forever.

10 best games in the last 3 months, I do believe
rankings should be ranking only the active people,
though of course when you look at an individual person
you could track their 'highest rank/score'

"I do believe
rankings should be ranking only the active people."

Yes, but not only the *most* active people.

Submitting a game every two weeks should be just fine, many people will not submit more than 10 games overall in three months. So 10 Best in 90 days would be too limited.

Ah what ever, i dont much care for how many games
per how many monthes, its the idea thats important

Perhaps your rankings could "go to sleep", should you not submit anything for more than 30 days, but be reawakened once you start submitting again.

Ok another suggestion.

N=NumberOFGames-1
Score[i]- array with scores sorted in descending order
C=Min(4,N) //so no less then 5 best games will be counted
D=Max(9,N) // so no more than 10 best games will be counted
PlayerScore=0;
Sum=0;
for (i=0;i(less or equal)D;i++)
{
Sum=Sum+Score[i];
if (i(equal or more)C)
{
PlayerScore=Max(PlayerScore;Sum/Sqrt(i));
}
}

~SDC~

I thought about this some more. I like this method:

Score[i] = scores sorted in descending order

rating = Sum(score[i]/i)

(The sum array is 1-based rather than 0-based, so there is no division by zero.)

This method never penalizes someone for submitting a bad score. It emphasizes your "best" games. If you try to beef up your rating by submitting lots of scores, there's a point of diminishing returns.