AoC2023/Day 7/main.cpp

#pragma region Hidden Setup Stuff
#define OLC_PGE_APPLICATION
#include "olcPixelGameEngine.h"

using namespace olc;

enum Run{
	FILE1,
	FILE2
};

// 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
};

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::doStuff,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