ChampionLeaguePointSolver/ChallengeLeaguePointSolver/ChallengeLeaguePointSolver_BruteForce.old

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <algorithm>

std::string slurp(std::ifstream& in) {
    std::ostringstream sstr;
    sstr << in.rdbuf();
    return sstr.str();
}

struct ScoreData{
    int difficulty=0;
    std::string song;
    int totalEX=0;
    int ex1=0,ex2=0,ex3=0;
    std::string str()const{
        return "["+std::to_string(difficulty)+"] "+song+": "+std::to_string(totalEX)+" total, "+" EX1: "+std::to_string(ex1)+" EX2: "+std::to_string(ex2)+" EX3: "+std::to_string(ex3);
    }
    friend std::ostream&operator<<(std::ostream&os,const ScoreData&data){
        os<<data.str();
        return os;
    }
};

struct Selection{
    std::vector<std::pair<int,int>>selectedScore;
    int totalEX=0;
};

std::string GetNext(int&marker,std::string str){
    int originalMarker=marker;
    marker=str.find_first_of(',',originalMarker)+1;
    return str.substr(originalMarker,marker-1);
};

int main(){
    std::vector<ScoreData>dataA,dataB;
	std::ifstream file("team.csv");
    std::string line;
    //First two lines are garbage data.
    std::getline(file,line);
    std::getline(file,line);
    for(int i=0;i<12;i++){
        std::getline(file,line);
        int marker=0;
        dataA.emplace_back(ScoreData{
            stoi(GetNext(marker,line)),
            GetNext(marker,line),
            stoi(GetNext(marker,line)),
            stoi(GetNext(marker,line)),
            stoi(GetNext(marker,line)),
            stoi(GetNext(marker,line))}
        );
    }
    //Two more lines of garbage data.
    std::getline(file,line);
    std::getline(file,line);
    for(int i=0;i<12;i++){
        std::getline(file,line);
        int marker=0;
        dataB.emplace_back(ScoreData{
            stoi(GetNext(marker,line)),
            GetNext(marker,line),
            stoi(GetNext(marker,line)),
            stoi(GetNext(marker,line)),
            stoi(GetNext(marker,line)),
            stoi(GetNext(marker,line))}
        );
    }
    std::cout<<"File Contents:"<<std::endl<<std::endl;
    for(auto&list:{dataA,dataB}){
        for(auto&dat:list){
            std::cout<<dat<<std::endl;
        }
    }
    std::cout<<"==================="<<std::endl;
    std::vector<Selection>bestSelections;
    Selection selection;
    ScoreData*dataRef;
    std::vector<int>sortedChoices={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23};
    std::sort(sortedChoices.begin(),sortedChoices.end(),[&](int&val1,int&val2){
            int ex1;
            int ex2;
            if(val1<12){
                ex1=dataA[val1].totalEX;
            }else{
                ex1=dataB[val1-12].totalEX;
            }
            if(val2<12){
                ex2=dataA[val2].totalEX;
            }else{
                ex2=dataB[val2-12].totalEX;
            }
            return ex1>ex2;
        });

    for(int a1=0;a1<24;a1++){
        int Aselections=6,Bselections=6;
        selection.selectedScore.clear();
        selection.totalEX=0;
        std::vector<int>remainingChoices=sortedChoices;
        int arrInd=a1;
        if(Aselections==0&&remainingChoices[a1]<12||Bselections==0&&remainingChoices[a1]>=12)continue;
        selection.selectedScore.push_back({0,remainingChoices[arrInd]});
        if(remainingChoices[arrInd]<12){
            Aselections--;
            dataRef=&dataA[remainingChoices[arrInd]];
        }else{
            Bselections--;
            dataRef=&dataB[remainingChoices[arrInd]-12];
        }
        selection.totalEX+=dataRef->ex1;
        remainingChoices.erase(remainingChoices.begin()+arrInd);
        for(int a2=0;a2<23;a2++){
            Selection selection2 = selection;
            int Aselections2=Aselections,Bselections2=Bselections;
            std::vector<int>remainingChoices2 = remainingChoices;
            int arrInd=a2;
            if(Aselections2==0&&remainingChoices2[a2]<12||Bselections2==0&&remainingChoices2[a2]>=12)continue;
            selection2.selectedScore.push_back({0,remainingChoices2[arrInd]});
            if(remainingChoices2[arrInd]<12){
                Aselections2--;
                dataRef=&dataA[remainingChoices2[arrInd]];
            }else{
                Bselections2--;
                dataRef=&dataB[remainingChoices2[arrInd]-12];
            }
            selection2.totalEX+=dataRef->ex1;
            remainingChoices2.erase(remainingChoices2.begin()+arrInd);
            if(bestSelections.size()>0&&selection2.totalEX<bestSelections.back().totalEX-(sortedChoices.front()<12?dataA[sortedChoices.front()].totalEX:dataB[sortedChoices.front()].totalEX)*10)continue;
            for(int a3=0;a3<22;a3++){
                Selection selection3 = selection2;
                std::vector<int>remainingChoices3 = remainingChoices2;
                int Aselections3=Aselections2,Bselections3=Bselections2;
                int arrInd=a3;
                if(Aselections3==0&&remainingChoices3[a3]<12||Bselections3==0&&remainingChoices3[a3]>=12)continue;
                selection3.selectedScore.push_back({0,remainingChoices3[arrInd]});
                if(remainingChoices3[arrInd]<12){
                    Aselections3--;
                    dataRef=&dataA[remainingChoices3[arrInd]];
                }else{
                    Bselections3--;
                    dataRef=&dataB[remainingChoices3[arrInd]-12];
                }
                selection3.totalEX+=dataRef->ex1;
                remainingChoices3.erase(remainingChoices3.begin()+arrInd);
                if(bestSelections.size()>0&&selection3.totalEX<bestSelections.back().totalEX-(sortedChoices.front()<12?dataA[sortedChoices.front()].totalEX:dataB[sortedChoices.front()].totalEX)*9)continue;
                for(int a4=0;a4<21;a4++){
                    Selection selection4 = selection3;
                    std::vector<int>remainingChoices4 = remainingChoices3;
                    int Aselections4=Aselections3,Bselections4=Bselections3;
                    int arrInd=a4;
                    if(Aselections4==0&&remainingChoices4[a4]<12||Bselections4==0&&remainingChoices4[a4]>=12)continue;
                    selection4.selectedScore.push_back({0,remainingChoices4[arrInd]});
                    if(remainingChoices4[arrInd]<12){
                        Aselections4--;
                        dataRef=&dataA[remainingChoices4[arrInd]];
                    }else{
                        Bselections4--;
                        dataRef=&dataB[remainingChoices4[arrInd]-12];
                    }
                    selection4.totalEX+=dataRef->ex1;
                    remainingChoices4.erase(remainingChoices4.begin()+arrInd);
                    if(bestSelections.size()>0&&selection4.totalEX<bestSelections.back().totalEX-(sortedChoices.front()<12?dataA[sortedChoices.front()].totalEX:dataB[sortedChoices.front()].totalEX)*8)continue;
                    for(int b1=0;b1<20;b1++){
                        Selection selection5 = selection4;
                        std::vector<int>remainingChoices5 = remainingChoices4;
                        int Aselections5=Aselections4,Bselections5=Bselections4;
                        int arrInd=b1;
                        if(Aselections5==0&&remainingChoices5[b1]<12||Bselections5==0&&remainingChoices5[b1]>=12)continue;
                        selection5.selectedScore.push_back({1,remainingChoices5[arrInd]});
                        if(remainingChoices5[arrInd]<12){
                            Aselections5--;
                            dataRef=&dataA[remainingChoices5[arrInd]];
                        }else{
                            Bselections5--;
                            dataRef=&dataB[remainingChoices5[arrInd]-12];
                        }
                        selection5.totalEX+=dataRef->ex2;
                        remainingChoices5.erase(remainingChoices5.begin()+arrInd);
                        if(bestSelections.size()>0&&selection5.totalEX<bestSelections.back().totalEX-(sortedChoices.front()<12?dataA[sortedChoices.front()].totalEX:dataB[sortedChoices.front()].totalEX)*7)continue;
                        for(int b2=0;b2<19;b2++){
                            Selection selection6 = selection5;
                            std::vector<int>remainingChoices6 = remainingChoices5;
                            int Aselections6=Aselections5,Bselections6=Bselections5;
                            int arrInd=b2;
                            if(Aselections6==0&&remainingChoices6[b2]<12||Bselections6==0&&remainingChoices6[b2]>=12)continue;
                            selection6.selectedScore.push_back({1,remainingChoices6[arrInd]});
                            if(remainingChoices6[arrInd]<12){
                                Aselections6--;
                                dataRef=&dataA[remainingChoices6[arrInd]];
                            }else{
                                Bselections6--;
                                dataRef=&dataB[remainingChoices6[arrInd]-12];
                            }
                            selection6.totalEX+=dataRef->ex2;
                            remainingChoices6.erase(remainingChoices6.begin()+arrInd);
                            if(bestSelections.size()>0&&selection6.totalEX<bestSelections.back().totalEX-(sortedChoices.front()<12?dataA[sortedChoices.front()].totalEX:dataB[sortedChoices.front()].totalEX)*6)continue;
                            for(int b3=0;b3<18;b3++){
                                Selection selection7 = selection6;
                                std::vector<int>remainingChoices7 = remainingChoices6;
                                int Aselections7=Aselections6,Bselections7=Bselections6;
                                int arrInd=b3;
                                if(Aselections7==0&&remainingChoices7[b3]<12||Bselections7==0&&remainingChoices7[b3]>=12)continue;
                                selection7.selectedScore.push_back({1,remainingChoices7[arrInd]});
                                if(remainingChoices7[arrInd]<12){
                                    Aselections7--;
                                    dataRef=&dataA[remainingChoices7[arrInd]];
                                }else{
                                    Bselections7--;
                                    dataRef=&dataB[remainingChoices7[arrInd]-12];
                                }
                                selection7.totalEX+=dataRef->ex2;
                                remainingChoices7.erase(remainingChoices7.begin()+arrInd);
                                if(bestSelections.size()>0&&selection7.totalEX<bestSelections.back().totalEX-(sortedChoices.front()<12?dataA[sortedChoices.front()].totalEX:dataB[sortedChoices.front()].totalEX)*5)continue;
                                for(int b4=0;b4<17;b4++){
                                    Selection selection8 = selection7;
                                    std::vector<int>remainingChoices8 = remainingChoices7;
                                    int Aselections8=Aselections7,Bselections8=Bselections7;
                                    int arrInd=b4;
                                    if(Aselections8==0&&remainingChoices8[b4]<12||Bselections8==0&&remainingChoices8[b4]>=12)continue;
                                    selection8.selectedScore.push_back({1,remainingChoices8[arrInd]});
                                    if(remainingChoices8[arrInd]<12){
                                        Aselections8--;
                                        dataRef=&dataA[remainingChoices8[arrInd]];
                                    }else{
                                        Bselections8--;
                                        dataRef=&dataB[remainingChoices8[arrInd]-12];
                                    }
                                    selection8.totalEX+=dataRef->ex2;
                                    remainingChoices8.erase(remainingChoices8.begin()+arrInd);
                                    if(bestSelections.size()>0&&selection8.totalEX<bestSelections.back().totalEX-(sortedChoices.front()<12?dataA[sortedChoices.front()].totalEX:dataB[sortedChoices.front()].totalEX)*4)continue;
                                    for(int c1=0;c1<16;c1++){
                                        Selection selection9 = selection8;
                                        std::vector<int>remainingChoices9 = remainingChoices8;
                                        int Aselections9=Aselections8,Bselections9=Bselections8;
                                        int arrInd=c1;
                                        if(Aselections9==0&&remainingChoices9[c1]<12||Bselections9==0&&remainingChoices9[c1]>=12)continue;
                                        selection9.selectedScore.push_back({2,remainingChoices9[arrInd]});
                                        if(remainingChoices9[arrInd]<12){
                                            Aselections9--;
                                            dataRef=&dataA[remainingChoices9[arrInd]];
                                        }else{
                                            Bselections9--;
                                            dataRef=&dataB[remainingChoices9[arrInd]-12];
                                        }
                                        selection9.totalEX+=dataRef->ex3;
                                        remainingChoices9.erase(remainingChoices9.begin()+arrInd);
                                        if(bestSelections.size()>0&&selection9.totalEX<bestSelections.back().totalEX-(sortedChoices.front()<12?dataA[sortedChoices.front()].totalEX:dataB[sortedChoices.front()].totalEX)*3)continue;
                                        for(int c2=0;c2<15;c2++){
                                            Selection selection10 = selection9;
                                            std::vector<int>remainingChoices10 = remainingChoices9;
                                            int Aselections10=Aselections9,Bselections10=Bselections9;
                                            int arrInd=c2;
                                            if(Aselections10==0&&remainingChoices10[c2]<12||Bselections10==0&&remainingChoices10[c2]>=12)continue;
                                            selection10.selectedScore.push_back({2,remainingChoices10[arrInd]});
                                            if(remainingChoices10[arrInd]<12){
                                                Aselections10--;
                                                dataRef=&dataA[remainingChoices10[arrInd]];
                                            }else{
                                                Bselections10--;
                                                dataRef=&dataB[remainingChoices10[arrInd]-12];
                                            }
                                            selection10.totalEX+=dataRef->ex3;
                                            remainingChoices10.erase(remainingChoices10.begin()+arrInd);
                                            if(bestSelections.size()>0&&selection10.totalEX<bestSelections.back().totalEX-(sortedChoices.front()<12?dataA[sortedChoices.front()].totalEX:dataB[sortedChoices.front()].totalEX)*2)continue;
                                            for(int c3=0;c3<14;c3++){
                                                Selection selection11 = selection10;
                                                std::vector<int>remainingChoices11 = remainingChoices10;
                                                int Aselections11=Aselections10,Bselections11=Bselections10;
                                                int arrInd=c3;
                                                if(Aselections11==0&&remainingChoices11[c3]<12||Bselections11==0&&remainingChoices11[c3]>=12)continue;
                                                selection11.selectedScore.push_back({2,remainingChoices11[arrInd]});
                                                if(remainingChoices11[arrInd]<12){
                                                    Aselections11--;
                                                    dataRef=&dataA[remainingChoices11[arrInd]];
                                                }else{
                                                    Bselections11--;
                                                    dataRef=&dataB[remainingChoices11[arrInd]-12];
                                                }
                                                selection11.totalEX+=dataRef->ex3;
                                                remainingChoices11.erase(remainingChoices11.begin()+arrInd);
                                                if(bestSelections.size()>0&&selection11.totalEX<bestSelections.back().totalEX-(sortedChoices.front()<12?dataA[sortedChoices.front()].totalEX:dataB[sortedChoices.front()].totalEX))continue;
                                                for(int c4=0;c4<13;c4++){
                                                    Selection selection12 = selection11;
                                                    std::vector<int>remainingChoices12 = remainingChoices11;
                                                    int Aselections12=Aselections11,Bselections12=Bselections11;
                                                    int arrInd=c4;
                                                    if(Aselections12==0&&remainingChoices12[c4]<12||Bselections12==0&&remainingChoices12[c4]>=12)continue;
                                                    selection12.selectedScore.push_back({2,remainingChoices12[arrInd]});
                                                    if(remainingChoices12[arrInd]<12){
                                                        Aselections12--;
                                                        dataRef=&dataA[remainingChoices12[arrInd]];
                                                    }else{
                                                        Bselections12--;
                                                        dataRef=&dataB[remainingChoices12[arrInd]-12];
                                                    }
                                                    selection12.totalEX+=dataRef->ex3;
                                                    if(bestSelections.size()>0){
                                                        int bestEX=bestSelections.back().totalEX;
                                                        if(selection12.totalEX>bestEX){
                                                            std::cout<<"New best EX combination found: "+std::to_string(selection12.totalEX)+". Selections are:"<<std::endl<<"\t";
                                                            for(std::pair<int,int>&song:selection12.selectedScore){
                                                                std::cout<<"P"<<song.first<<"|"<<song.second<<",";
                                                            }
                                                            std::cout<<std::endl;
                                                            bestSelections.push_back(selection12);
                                                        }
                                                    }else{
                                                        bestSelections.push_back(selection12);
                                                        std::cout<<"New best EX combination found: "+std::to_string(selection12.totalEX)+". Selections are:"<<std::endl<<"\t";
                                                        for(std::pair<int,int>&song:selection12.selectedScore){
                                                            std::cout<<"P"<<song.first<<"|"<<song.second<<",";
                                                        }
                                                        std::cout<<std::endl;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    std::cout<<"Done"<<std::endl;
}