Mikescher/www.mikescher.com
1
0
Fork 0
Code Actions Activity

rename statics/euler and sync b93 code with main repo

Browse Source
This commit is contained in:
Mike Schwörer
2017-11-20 17:38:54 +01:00
parent 0efeb3afeb
commit 69e3f51730
409 changed files with 745 additions and 509 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
www/statics/euler/Euler_Problem-054_explanation.md Normal file
View File

@@ -0,0 +1,68 @@
Yep, I *hate* this problem.
Not only is there an enormous amount of input data that makes our program huge in size.
But it contains a lot of different cases, rules and logic that needs be represented in our program
But none the less I tried to come up with an compact algorithm for scoring a set of cards
~~~
Get(@"https://projecteuler.net/project/resources/p054_poker.txt")
.Where(p => GetScore(p.deck_1) > GetScore(p.deck_2))
.Count()
.Dump();
~~~
~~~
int GetScore(Card[] cards) {
List<long> SUMS = new List<long>{ H*H*H*H*H, C*C*C*C*C, S*S*S*S*S, D*D*D*D*D };
int[] array = new int[15];
int score = 0;
int flushSum = 1;
int highCard = 0;
int highGroup = 0;
int straightIndex = 0;
foreach(Card c in cards) {
highCard = Math.Max(highCard, c.value);
flushSum *= c.suit;
if (array[c.value] > 0)
highGroup = Math.Max(highGroup, c.value);
array[c.value]++;
}
for(int i = 1; i < 15; i++)
{
score += (array[i]-1)*(array[i])*256;
if (array[i] > 0 && array[i-1] > 0)
straightIndex++;
}
score += highCard;
score += highGroup * 15;
if (straightIndex == 4)
score += 2540;
if (SUMS.Contains(flushSum))
score += 2550;
return score;
}
~~~
The different values are carefully crafted in such a way, that you can compare the score of two hands and get the winner
Card | Calculation | Score
---------------------|----------------|---------------------------------------------
High Card | {0-14} * [1] | = {0-14}
High Card (in Group) | {0-14} * [15] | = {0-210}
One Pair | 2 * [256] | = 512 *(+ HighCard)* *(+ HighGroup)*
Two Pairs | 4 * [256] | = 1024 *(+ HighCard)* *(+ HighGroup)*
Three of a Kind | 6 * [256] | = 1536 *(+ HighCard)* *(+ HighGroup)*
Straight | [2540] | = 2540 *(+ HighCard)* *(+ HighGroup)*
Flush | [2550] | = 2550 *(+ HighCard)* *(+ HighGroup)*
Full House | 10 * [256] | = 2560 *(+ HighCard)* *(+ HighGroup)*
Four of a Kind | 12 * [256] | = 3072 *(+ HighCard)* *(+ HighGroup)*
Straight Flush | [2540] + [2550]| = 5090 *(+ HighCard)* *(+ HighGroup)*
Royal Flush | [2540] + [2550]| = 5090 *(+ HighCard)* *(+ HighGroup)*
One last side note: A **royal flush** is not really a independent rank. Because of the "highest card in the rank" rule a royal flush is always better than a straight flush (because the highest card is an ace)