CryingLoser: I don't think changing time frames part way through a tournament is a good idea at all. I do however think that if a player can not possibly go on to the next round it should not hold up the next round from starting.

mctrivia: This does not solve the prob. If a player is so slow that he has not finished a single game while all the others have finished their games (except with him), the system believes it is possible that he can win the round even if he is the weakest player in the tournament. So it will hold up the next round. Hence i remain in the suggestion for tournaments in new modus (flexible time frames). Of course, it should remain the option to create a tournament with the old modus.

pattypoo: Since the conditions will be known before the tournament start, there is no surprise and a player can chose if he want to join a tournament with flexible frames or one with unflexible. Cannot see something unfair here...

CryingLoser: The problem is that there are so many exceptions that it would be impossible to implement. For instance, a Dice Chess game can be over in 4 moves, but it can also last for 50 moves. The suggested system would penalize someone because in his games, the games last for 50 moves (which he actually may play quite fast), while the other games were all finished in 4 moves (played quite slow).

Or someone might be away on a three week vacation; the tournament he signed up for started three weeks early because it reached the required number of players, and all the other games were finished before the player returns from vacation.

Furthermore, any game is played by two people. No tournament can depend on just one player to finish his/her games.

AbigailII: Fortunately, the exception you mentioned is an extreme rarity. Let's take from
Retep
a spot check of 10 games, we get an average of 19.4 moves per game and variance sigma^2 = 132.93. Probability that a game ends in 50 moves = phi(50; 19.4, 132.93) = 0.00292267, that it ends in 4 moves = 0.00298107. Probability
that in a 8-player-tournament just one player ends all his 7 games in 50 moves while all the other 49 ghames end in 4 moves = 0.0292267^7*0.0298107^49 =
3.19*10^-86. We should make a lot of tournaments - more tournaments than atoms in the universe! - in order that the situation, that a player will be accidentally be detected as "hand-brake" coz he has just 50-moves-games while all other have 4-moves-games, occurs even a single time...

About vacation no other comment that every player has vacation days from the server. It's the job of Fencer if he will give more or less vacation days.

But enough said, this theme seem to cause so much trouble that i don't want any longer suggest a solution for all of us but found a solution for myself: Today i quit all fellowships and will
not start in new tournaments.

CryingLoser: well - that would certainly solve your problem - i think maybe creating your own tournaments with your own time limits might help - maybe your own fellowship...

CryingLoser: The solution is simple - if you don't like other players taking the time they can in a tournament, play in different tournaments yourself that has time limits that fit your need better.

If I were to join a 7 day tournament because I like to play slow, it would be unfair to punish me by putting it down to 1 day a move because other players in the tournament decided they wanted a faster tournament.

So again, best solution - join tournaments with time limits that best suits your needs and not try to change how others play.

BIG BAD WOLF: What do you mean, not try to change how others play????? I've never done that, hell i can't olay myself..

pattypoo: Um..... unless you are using multiple accounts and got them confused, I did not address that message to you.

It was address to others who have signed up for a tournament with a set time limit, but then after the tournament is going, they are unhappy about it and want to change it for everyone else to make it easier for them. Which of course the easiest solution is to accept that everyone plays different, and the best option is to find what works best for you and not try to change everything to work for only you.

If I somehow made it seem like my reply to someone else was directed towards you, then please accept my apologize - I thought it was clear but possible was not.

My sugestion may not remove all hand brakes but it will allow tournaments to go on sooner unless the winner is the slowest player

mctrivia: I second that. Even if the winner of a section is decided, e.g. nobody of that section can get more points/SB points tham him/her, a tournament can go on.

joshi tm: I also second that, even though as CryingLoser said, this would not be enough when one player has not finished any game before all other games in the pool have finished.
But it may be a bit tedious to write the algorithm which checks whether the winner of a section is certain. If someone volunteered to write the Java code for that, it might speed up things :-)

nabla: It's not that hard to write an algorithm that can determine the winner regardless of the outcome of the outstanding matches most of the time isn't too hard:

For each player i, let W_i the number of wins he has, D_i the number of draws, and U_i the number of undecided games. There is a winner if there is an i such that W_i + D_i / 2 > W_j + D_j/2 + U_j, for all j != i. This is trivial to calculate. The only winners you might miss are the winners who finish with the same amount of points as other players, but win on SB.

AbigailII: I meant an algorithm including the SB calculation. More convoluted, but definitely possible : a trivial solution is to try all possible results, but that does not sound efficient.

nabla: Efficient? Well, that cost a computer just one split second more to define!!

joshi tm: Fair enough, but don't forget to multiply that split second by the number of unfinished groups in all running tournaments !

nabla:
<b>nabla</b>: The absolute simplest way to calculate absolute winner.

x=0;
do
{
  maylose=false;
  y=0;
  while (y<players && maylose==false)
  {
    if x!=y
    {
      if player[x].points<player[y].points+player[y].notdone
        maylose=true;
    }
    y++;
  }
  x++
} while (x<players && maylose==true)
if maylose==false
{
  //player[x-1] is the winner
}

It works under the principle that if player x loses all his games and every other player wins all there games and he still beats them then he is definetly the winner.

mctrivia: That's basically what I said. However, that doesn't take SB into account - which is what nabla wants.

I don't know of an efficient algorithm that will determine whether there's a winner, even if the winner has to be decided on SB points. Sure, trying all outcomes of a match may work, but that's a lot of combinations. Take for instance a tournament with 6 players, every one playing two games against each other. All games are finished, except for one player, he hasn't finished any game yet. Then there are 7,776 different ways of the 10 games to finish (well, 59,049, but you don't have to consider player A winning one game and losing the other game against player B separately). In a group of 8, there would be 279,936 possibilities (4,782,969 without eliminating symmetries).

AbigailII:   We can only advance if there is no way for any other player to win.  If the game has to be calculated on SB there is no way to garante that the player has one except in the small case were both players have the same points and neither of them can be beat by anyone else.  But this case only happens if those players games are all finished.

AbigailII: But there are efficient ways to search the tree. So the leading player will be assumed to lose all his/her games, then you test the 2nd player's games etc... until someone else can win. No need to traverse the whole tree.

grenv: No. I was discussing the case where the winner will be determined on SB points (the case of a sole winner I have already described - that's both trivial and efficient). For SB points, all games in the tournament are relevant, even of players that have no chance of winning. (Ok, ok, if there are two players A and B that have the most points (and hence their scores are tied) and there are players C and D that both won all their games against A and B, the outcome of the games between C and D doesn't matter for the SB points of A and B).

Remember that the SB of a player i equals Σ s_j P_j, (summing over all opponents j), with s_j the score i got in his game(s) against j, and P_j the total number of points j got.

AbigailII: Ok, I kind of meant that without being clear. so i see further down in the thread you describe an algorithm that works for the simple case.
So if T=W+D/2 for the leader, and T(n)=W+D/2+U for the others for simplicity

So if you are searching to see if T > T(n) for all n

If it doesn't then you need to see if T=Tn for each value of n. If it does then you would just search through a tree to determine if any combination of results ends up with the leaders S-B score being less than the challengers. That's what I meant by being efficient. You don't need to take into account every possible outcome.

BIG BAD WOLF: Actually the easiest solution is to simply send a message to the player who is slowing down the tournament and ask him/her to play faster.