1:
2:
3:
4:

Spieler 1        Spieler 2
9                9
8                8
...              ...

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

BenBE   Tastaro
1       9
2       8
3       7
4       6
5       5
6       4
7       3
8       2
9       1

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

BenBE/Daniel   Tastaro
1              9
9              8
8              7
7              6
6              5
5              4
4              3
3              2
2              1
================
8              1

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:

static void Main(string[] args) 
{
            List<Card> cards = new List<Card> { new Card(1), new Card(2), new Card(3) };
            int loops = 1000000;
            List<Result> results = new List<Result>();

            for (int i = 0; i < loops; i++)
            {
                results.Add(PlayRound(cards,  new RandomPlayer(), new UpDownPlayer()));
            }

            int winsP1 = results.Count(delegate (Result r)
            {
                return r.Winner.Equals("Player1");
            });

            int winsP2 = results.Count(delegate (Result r)
            {
                return r.Winner.Equals("Player2");
            });

            Console.WriteLine("Player1 won {0}% ({1}/{2})", (100f / loops) * winsP1, winsP1, winsP2);
}
        private static Result PlayRound(List<Card> cards, Player player1, Player player2)
        {
            Result result = new Result();
            player1.SetCards(new List<Card>(cards));
            player2.SetCards(new List<Card>(cards));

            for (int i = 0; i < cards.Count; i++)
            {
                Card card_p1 = player1.PutCard();
                Card card_p2 = player2.PutCard();

                if (card_p1 > card_p2)
                {
                    result.Wins++;
                }
                else if (card_p2 > card_p1)
                {
                    result.Looses++;
                }
                else
                {
                    result.Draws++;
                }
            }

            return result;
        }

1:
2:
3:
4:
5:
6:
7:
8:

        public override Card PutCard()
        {
            int index = _random.Next(0, _cards.Count);
            Card c = _cards[index];
            this._cards.RemoveAt(index);

            return c;
        }

1:
2:
3:
4:
5:
6:

        public override Card PutCard()
        {
            Card c = this._cards.Max<Card>();
                this._cards.Remove(c);
            return c;
        }

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:

BenBE/Daniel   Guinnes
1              9
9              1
8              8
7              7
6              6
5              5
4              4
3              3
2              2
================
1              1
Und wenn du dich auch auf meine Strategie einstellst :
BenBE/Daniel   Guinnes
1              9
9              1
2              8
7              2
3              6
5              3
4              4
8              8
6              6
================
3              3

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

BenBE/Daniel   Guinnes
1              9
9              1
2              8
7              2
3              6
5              3
4              4
8              5
6              7
================
4              4

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

        public override Card PutCard()
        {
            if (_opponentPlayed.Count == 0)
            {
                Card c = this._cards[this._cards.Count / 2];
                this._cards.Remove(c);
                return c;
            }
            else
            {
                int sum = 0;
                foreach (var card in _opponentPlayed)
                {
                    sum += card.Value;
                }

                float avager = sum / _opponentPlayed.Count;

                Card c = this._cards[(int) Math.Min(Math.Round(avager,0), this._cards.Count - 1)];
                this._cards.Remove(c);

                return c;
            }
        }