You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
498 lines
11 KiB
498 lines
11 KiB
#pragma region Includes
|
|
#define OLC_PGE_APPLICATION
|
|
#include "olcPixelGameEngine.h"
|
|
#include <set>
|
|
|
|
using namespace olc;
|
|
|
|
|
|
enum Run{
|
|
FILE1,
|
|
FILE2
|
|
};
|
|
#pragma endregion
|
|
#pragma region Hidden Setup Stuff
|
|
// Override base class with your custom functionality
|
|
class AoC2023 : public olc::PixelGameEngine
|
|
{
|
|
std::vector<std::string>lines;
|
|
bool waitForRender=false;
|
|
|
|
void wait(int pauseMs=0){
|
|
waitForRender=true;
|
|
while(waitForRender);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(pauseMs));
|
|
}
|
|
|
|
#pragma endregion
|
|
|
|
|
|
const int DAY = 7;
|
|
Run runInput=FILE2;
|
|
|
|
struct Hand{
|
|
std::vector<int>cards;
|
|
std::map<int,int>cardCounts;
|
|
int bid;
|
|
};
|
|
|
|
friend std::ostream&operator<<(std::ostream&rhs,const Hand&hand){
|
|
for(int i:hand.cards){
|
|
rhs<<i<<",";
|
|
}
|
|
rhs<<",,"<<hand.bid;
|
|
return rhs;
|
|
};
|
|
|
|
enum{
|
|
FIVE_OF_A_KIND,
|
|
FOUR_OF_A_KIND,
|
|
FULL_HOUSE,
|
|
THREE_OF_A_KIND,
|
|
TWO_PAIR,
|
|
ONE_PAIR,
|
|
HIGH_CARD
|
|
};
|
|
|
|
int CalculateHandRank(Hand&hand){
|
|
int maxSame=0;
|
|
int twoOfAKindCount=0;
|
|
for(auto&[key,value]:hand.cardCounts){
|
|
if(value>maxSame)maxSame=value;
|
|
if(value==2)twoOfAKindCount++;
|
|
}
|
|
if(maxSame==5)return FIVE_OF_A_KIND;
|
|
else if(maxSame==4)return FOUR_OF_A_KIND;
|
|
else if(maxSame==3){
|
|
if(twoOfAKindCount>0){
|
|
return FULL_HOUSE;
|
|
}else{
|
|
return THREE_OF_A_KIND;
|
|
}
|
|
}else if(maxSame==2){
|
|
if(twoOfAKindCount==2){
|
|
return TWO_PAIR;
|
|
}else{
|
|
return ONE_PAIR;
|
|
}
|
|
}else return HIGH_CARD;
|
|
};
|
|
|
|
void doStuff2(){
|
|
while(true){ //lines is accessible as a global.
|
|
std::vector<Hand>hands;
|
|
for(std::string&line:lines){
|
|
Hand hand;
|
|
for(int i=0;i<5;i++){
|
|
int cardRank=0;
|
|
switch(line[i]){
|
|
case 'J':cardRank=0;break;
|
|
case '2':cardRank=1;break;
|
|
case '3':cardRank=2;break;
|
|
case '4':cardRank=3;break;
|
|
case '5':cardRank=4;break;
|
|
case '6':cardRank=5;break;
|
|
case '7':cardRank=6;break;
|
|
case '8':cardRank=7;break;
|
|
case '9':cardRank=8;break;
|
|
case 'T':cardRank=9;break;
|
|
case 'Q':cardRank=10;break;
|
|
case 'K':cardRank=11;break;
|
|
case 'A':cardRank=12;break;
|
|
}
|
|
hand.cards.push_back(cardRank);
|
|
hand.cardCounts[cardRank]++;
|
|
}
|
|
hand.bid=std::stoi(line.substr(5));
|
|
hands.push_back(hand);
|
|
}
|
|
|
|
|
|
|
|
auto findHighestCardNonJoker=[](Hand&hand){
|
|
int highest=-1;
|
|
for(int i=0;i<hand.cards.size();i++){
|
|
if(hand.cards[i]!=0&&hand.cards[i]>highest)highest=hand.cards[i];
|
|
}
|
|
return highest;
|
|
};
|
|
auto findMostFrequentCardNonJoker=[](Hand&hand){
|
|
int highest=-1;
|
|
int count=-1;
|
|
for(auto&[key,value]:hand.cardCounts){
|
|
if(key!=0){
|
|
if(value>count){
|
|
highest=key;
|
|
count=value;
|
|
}else
|
|
if(value==count&&key>highest){
|
|
highest=key;
|
|
}
|
|
}
|
|
}
|
|
return highest;
|
|
};
|
|
|
|
auto CreateHand = [](std::vector<int>&newHand)->Hand{
|
|
Hand h;
|
|
for(int i:newHand){
|
|
h.cards.push_back(i);
|
|
h.cardCounts[i]++;
|
|
}
|
|
return h;
|
|
};
|
|
|
|
for(int counter=0;Hand&hand:hands){
|
|
if(hand.cardCounts[0]>0){
|
|
int bestRank=HIGH_CARD;
|
|
std::map<int,int>bestCardCount;
|
|
std::set<int>jokerToCardNumbers;
|
|
for(auto&[key,value]:hand.cardCounts){
|
|
if(key!=0)jokerToCardNumbers.insert(key);
|
|
}
|
|
std::vector<int>jokerPositions;
|
|
for(int counter=0;int i:hand.cards){
|
|
if(i==0)jokerPositions.push_back(counter);
|
|
counter++;
|
|
}
|
|
|
|
if(jokerPositions.size()==5){
|
|
bestRank=FIVE_OF_A_KIND;
|
|
bestCardCount=hand.cardCounts;
|
|
goto done;
|
|
}
|
|
|
|
if(jokerPositions.size()==4){
|
|
for(auto&key:jokerToCardNumbers){
|
|
std::vector<int>newHand=hand.cards;
|
|
newHand[jokerPositions[0]]=key;
|
|
for(auto&key:jokerToCardNumbers){
|
|
std::vector<int>newHand2=newHand;
|
|
newHand2[jokerPositions[1]]=key;
|
|
for(auto&key:jokerToCardNumbers){
|
|
std::vector<int>newHand3=newHand2;
|
|
newHand3[jokerPositions[2]]=key;
|
|
for(auto&key:jokerToCardNumbers){
|
|
std::vector<int>newHand4=newHand3;
|
|
newHand4[jokerPositions[3]]=key;
|
|
Hand newHand=CreateHand(newHand4);
|
|
int rank=CalculateHandRank(newHand);
|
|
if(rank<bestRank){
|
|
bestRank=rank;
|
|
bestCardCount=newHand.cardCounts;
|
|
if(bestRank==FIVE_OF_A_KIND)goto done;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}else
|
|
if(jokerPositions.size()==3){
|
|
for(auto&key:jokerToCardNumbers){
|
|
std::vector<int>newHand=hand.cards;
|
|
newHand[jokerPositions[0]]=key;
|
|
for(auto&key:jokerToCardNumbers){
|
|
std::vector<int>newHand2=newHand;
|
|
newHand2[jokerPositions[1]]=key;
|
|
for(auto&key:jokerToCardNumbers){
|
|
std::vector<int>newHand3=newHand2;
|
|
newHand3[jokerPositions[2]]=key;
|
|
Hand newHand=CreateHand(newHand3);
|
|
int rank=CalculateHandRank(newHand);
|
|
if(rank<bestRank){
|
|
bestRank=rank;
|
|
bestCardCount=newHand.cardCounts;
|
|
if(bestRank==FIVE_OF_A_KIND)goto done;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}else
|
|
if(jokerPositions.size()==2){
|
|
for(auto&key:jokerToCardNumbers){
|
|
std::vector<int>newHand=hand.cards;
|
|
newHand[jokerPositions[0]]=key;
|
|
for(auto&key:jokerToCardNumbers){
|
|
std::vector<int>newHand2=newHand;
|
|
newHand2[jokerPositions[1]]=key;
|
|
Hand newHand=CreateHand(newHand2);
|
|
int rank=CalculateHandRank(newHand);
|
|
if(rank<bestRank){
|
|
bestRank=rank;
|
|
bestCardCount=newHand.cardCounts;
|
|
if(bestRank==FIVE_OF_A_KIND)goto done;
|
|
}
|
|
}
|
|
}
|
|
}else{
|
|
for(auto&key:jokerToCardNumbers){
|
|
std::vector<int>newHand0=hand.cards;
|
|
newHand0[jokerPositions[0]]=key;
|
|
Hand newHand=CreateHand(newHand0);
|
|
int rank=CalculateHandRank(newHand);
|
|
if(rank<bestRank){
|
|
bestRank=rank;
|
|
bestCardCount=newHand.cardCounts;
|
|
if(bestRank==FIVE_OF_A_KIND)goto done;
|
|
}
|
|
}
|
|
}
|
|
|
|
done:
|
|
hand.cardCounts=bestCardCount;
|
|
}
|
|
counter++;
|
|
}
|
|
|
|
std::array<std::vector<int>,7>handScores{}; //Contains indices in hands vector of the different score pools.
|
|
for(int counter=0;Hand&hand:hands){
|
|
handScores[CalculateHandRank(hand)].push_back(counter);
|
|
counter++;
|
|
}
|
|
|
|
for(int i:handScores[FIVE_OF_A_KIND]){
|
|
Hand&h=hands[i];
|
|
std::map<int,int>cards;
|
|
for(int card:h.cards){
|
|
cards[card]++;
|
|
}
|
|
if(cards.size()!=1){
|
|
if(cards[0]==0){
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
for(int i:handScores[FOUR_OF_A_KIND]){
|
|
Hand&h=hands[i];
|
|
std::map<int,int>cards;
|
|
for(int card:h.cards){
|
|
cards[card]++;
|
|
}
|
|
if(cards.size()!=2){
|
|
if(cards[0]==0)throw;
|
|
}
|
|
}
|
|
for(int i:handScores[FULL_HOUSE]){
|
|
Hand&h=hands[i];
|
|
std::map<int,int>cards;
|
|
int card1=-1;
|
|
int card2=-1;
|
|
for(int card:h.cards){
|
|
if(card1==card||card2==card)continue;
|
|
if(card==0)continue;
|
|
if(card1==-1)card1=card;
|
|
else if(card2==-1)card2=card;
|
|
else if(card!=0)throw;
|
|
}
|
|
if(card1==-1||card2==-1)throw;
|
|
}
|
|
for(int i:handScores[THREE_OF_A_KIND]){
|
|
Hand&h=hands[i];
|
|
bool threeFound=false;
|
|
bool twoFound=false;
|
|
for(auto&[key,value]:h.cardCounts){
|
|
if(value==3)threeFound=true;
|
|
if(value==2)throw;
|
|
}
|
|
}
|
|
for(int i:handScores[TWO_PAIR]){
|
|
Hand&h=hands[i];
|
|
int pairCounts=0;
|
|
for(auto&[key,value]:h.cardCounts){
|
|
if(value==2)pairCounts++;
|
|
}
|
|
if(pairCounts!=2)throw;
|
|
}
|
|
for(int i:handScores[ONE_PAIR]){
|
|
Hand&h=hands[i];
|
|
int pairCounts=0;
|
|
for(auto&[key,value]:h.cardCounts){
|
|
if(value==2)pairCounts++;
|
|
}
|
|
if(pairCounts!=1)throw;
|
|
}
|
|
for(int i:handScores[HIGH_CARD]){
|
|
Hand&h=hands[i];
|
|
for(auto&[key,value]:h.cardCounts){
|
|
if(key==0&&value>0)throw;
|
|
}
|
|
if(h.cardCounts.size()<5)throw;
|
|
}
|
|
|
|
auto handSort=[&](int h1,int h2){
|
|
std::vector<int>&cards1=hands[h1].cards;
|
|
std::vector<int>&cards2=hands[h2].cards;
|
|
for(int i=0;i<5;i++){
|
|
if(cards1[i]>cards2[i])return true;
|
|
else if(cards2[i]>cards1[i])return false;
|
|
}
|
|
return true;
|
|
};
|
|
|
|
for(int i=0;i<=HIGH_CARD;i++){
|
|
if(handScores[i].size()>1){
|
|
std::sort(handScores[i].begin(),handScores[i].end(),handSort);
|
|
}
|
|
}
|
|
|
|
long long score=0;
|
|
|
|
int rank=hands.size();
|
|
for(int i=0;i<=HIGH_CARD;i++){
|
|
std::cout<<"----------------"<<std::endl;
|
|
for(int hand:handScores[i]){
|
|
Hand&h=hands[hand];
|
|
std::cout<<h<<std::endl;
|
|
score+=h.bid*rank;
|
|
rank--;
|
|
}
|
|
}
|
|
|
|
std::cout<<score<<std::endl;
|
|
|
|
break;
|
|
//wait(0); //Wait for 0ms and render the screen (calls draw())
|
|
}
|
|
}
|
|
|
|
void doStuff(){
|
|
while(true){ //lines is accessible as a global.
|
|
std::vector<Hand>hands;
|
|
for(std::string&line:lines){
|
|
Hand hand;
|
|
for(int i=0;i<5;i++){
|
|
int cardRank=0;
|
|
switch(line[i]){
|
|
case '2':cardRank=0;break;
|
|
case '3':cardRank=1;break;
|
|
case '4':cardRank=2;break;
|
|
case '5':cardRank=3;break;
|
|
case '6':cardRank=4;break;
|
|
case '7':cardRank=5;break;
|
|
case '8':cardRank=6;break;
|
|
case '9':cardRank=7;break;
|
|
case 'T':cardRank=8;break;
|
|
case 'J':cardRank=9;break;
|
|
case 'Q':cardRank=10;break;
|
|
case 'K':cardRank=11;break;
|
|
case 'A':cardRank=12;break;
|
|
}
|
|
hand.cards.push_back(cardRank);
|
|
hand.cardCounts[cardRank]++;
|
|
}
|
|
hand.bid=std::stoi(line.substr(5));
|
|
hands.push_back(hand);
|
|
}
|
|
std::array<std::vector<int>,7>handScores{}; //Contains indices in hands vector of the different score pools.
|
|
for(int counter=0;Hand&hand:hands){
|
|
int maxSame=0;
|
|
int twoOfAKindCount=0;
|
|
for(auto&[key,value]:hand.cardCounts){
|
|
if(value>maxSame)maxSame=value;
|
|
if(value==2)twoOfAKindCount++;
|
|
}
|
|
if(maxSame==5)handScores[FIVE_OF_A_KIND].push_back(counter);
|
|
else if(maxSame==4)handScores[FOUR_OF_A_KIND].push_back(counter);
|
|
else if(maxSame==3){
|
|
if(twoOfAKindCount>0){handScores[FULL_HOUSE].push_back(counter);}else{
|
|
handScores[THREE_OF_A_KIND].push_back(counter);
|
|
}
|
|
}else if(maxSame==2){
|
|
if(twoOfAKindCount==2){
|
|
handScores[TWO_PAIR].push_back(counter);
|
|
}else{
|
|
handScores[ONE_PAIR].push_back(counter);
|
|
}
|
|
}else handScores[HIGH_CARD].push_back(counter);
|
|
counter++;
|
|
}
|
|
|
|
auto handSort=[&](int h1,int h2){
|
|
std::vector<int>&cards1=hands[h1].cards;
|
|
std::vector<int>&cards2=hands[h2].cards;
|
|
for(int i=0;i<5;i++){
|
|
if(cards1[i]>cards2[i])return true;
|
|
else if(cards2[i]>cards1[i])return false;
|
|
}
|
|
return true;
|
|
};
|
|
|
|
for(int i=0;i<=HIGH_CARD;i++){
|
|
if(handScores[i].size()>1){
|
|
std::sort(handScores[i].begin(),handScores[i].end(),handSort);
|
|
}
|
|
}
|
|
|
|
long long score=0;
|
|
|
|
int rank=hands.size();
|
|
for(int i=0;i<=HIGH_CARD;i++){
|
|
std::cout<<"----------------"<<std::endl;
|
|
for(int hand:handScores[i]){
|
|
Hand&h=hands[hand];
|
|
std::cout<<h<<std::endl;
|
|
score+=h.bid*rank;
|
|
rank--;
|
|
}
|
|
}
|
|
|
|
std::cout<<score<<std::endl;
|
|
|
|
break;
|
|
//wait(0); //Wait for 0ms and render the screen (calls draw())
|
|
}
|
|
}
|
|
|
|
void draw(){ //Only use Sprites! If using decals, you must reference global variables!
|
|
Clear(BLACK);
|
|
int count=0;
|
|
for(std::string&line:lines){
|
|
DrawString({0,count*32},line,WHITE,4);
|
|
count++;
|
|
}
|
|
}
|
|
|
|
#pragma region Hidden Engine Stuff
|
|
public:
|
|
AoC2023()
|
|
{
|
|
// Name your application
|
|
std::string fileName="day"+std::to_string(DAY)+"_1.txt";
|
|
if(runInput==FILE2){fileName="day"+std::to_string(DAY)+"_2.txt";}
|
|
std::ifstream file(fileName);
|
|
while(file.good()){
|
|
std::string line;
|
|
std::getline(file,line);
|
|
lines.push_back(line);
|
|
}
|
|
|
|
sAppName = "Advent of Code 2023 - Day "+std::to_string(DAY);
|
|
}
|
|
|
|
public:
|
|
bool OnUserCreate() override
|
|
{
|
|
|
|
return true;
|
|
}
|
|
|
|
bool OnUserUpdate(float fElapsedTime) override
|
|
{
|
|
static std::thread aocSolver(&AoC2023::doStuff2,this);
|
|
|
|
if(waitForRender){
|
|
draw();
|
|
waitForRender=false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
int main()
|
|
{
|
|
AoC2023 game;
|
|
if (game.Construct(640, 480, 2, 2))
|
|
game.Start();
|
|
return 0;
|
|
}
|
|
#pragma endregion |