From 2cf4f06dd05296e6011bb0b9db3e763e62789ae1 Mon Sep 17 00:00:00 2001 From: Luke Else Date: Sun, 4 Dec 2022 20:29:01 +0000 Subject: [PATCH] Completed Day3 - Very verbose code, could do with some cleanup --- input/day03 | 300 +++++++++++++++++++++++++++++++++++++++++++++ src/days/day03.cpp | 103 +++++++++++++++- 2 files changed, 401 insertions(+), 2 deletions(-) diff --git a/input/day03 b/input/day03 index e69de29..28b7adb 100644 --- a/input/day03 +++ b/input/day03 @@ -0,0 +1,300 @@ +GbccTtTSGGbgrcWBGGrdgTnVQnCmNpCJlNnNPVfClcnN +vMzvZhzhwDLVmQnClwwNQp +FRsZFzjQFsqRzRRjDZbdtTgdHBBWGrdBdHHs +HCLTmbCLgzNBNPSSlT +JJGMWRJMrrdwWWGjGWMLRGLjBzNQsBzPPfflzDPBsBffDrQz +pwJdLMjdMddWjLtwZWMMwGtHhnvnCnhvqVFFZnvbgbqVCZ +tvMCDCSVVvDDBQFRbqWMMsWgFWgc +BLLPTpBmfLPrHLLfLsbhRqbzRRcRHgqssR +dfdNLmPTdNZmZdZPfpmTJLPPSvQjtSGVwQSDJSjSwDQBVCGw +wZWTWNFqzwZbWNpSgGMVMtTHsgGs +nlnPnPvLQjzdtsjBHBMMGSHg +LdnrrLnhRdLLmLDRPvmdQnJDJWNqcCqZJZqfFqfcfzcq +vPTbfWggzvGVqjsVqV +dDcJHZcZHmMFQQMshsjcRqVChjNtqh +dDHJDmFnrJmQFnBdMdQHJdZZlWTTPPjTLWbTzLWlTTfwjzBT +VfmDHDfZzfLcZLLLHBFQtRJTcdjgdTgFjjtR +WRPhMlGSshPRGgvFMtddTjjCQt +SPhWPsbNWShsWllswGpzLmzfZwmZfqLVRrDBZB +MtZgRgJJbbGjgDDgbjRjRbGcNdWwncBFdLBBMhFBQwnWnw +vlpsNVsCzzfHpvTpzlSSSvppcQdfnwnWhndWndwfQLhnhcFQ +pCsCCTHVvSzvPvHvzpPVTVHHRJJDgJZjJjqNmjZmDtJRZPNR +GTGTbhhPjJJjBhhZsGzmfHSNsmHHgSdL +FcFpMDFDRFfsRHSjmLjR +CpFjqcCjwjnpwhTPTWBQZZTb +zdzzwDlnTDQQQQnqQqqsFqnrSBSprbpjNJJBJPPdpJfbZb +hgMcRVGMtHgRcNSPrpfgfjJpBp +CLRHVHhtvtvGPWFFDqPDLnqP +jssjjjHCSGCMNJTWWCJT +DvcvBtVrrDSNWcMfLRfM +ppDZSpBhBvBmvDHnFsHHPnGPGbQp +VVVLsLWnjVVBGgScjtBjjLLgmJdPmJmfmhmGmmmNmJGhPNJP +QbqlZqQTZvMHmshvFhPfffFp +CsTRrQrwbCbrZqQTQlRjtDBSBtwBjgVWLBtgBt +FLsSFRTPscHZmGRGGc +npNNptgttCNpgLbnQMgnQnMNqVhGqZrmrmmqrmcrqmCVZwqH +WMWbtpjLgnLNvSfPPzjvjPdv +FcFFhZlhlMrHlSFSrHZMJZSVmmLmVLLCsBtLBCzCBVDRcV +PMGPbndvGfGstLzDCmLB +NwjPqdvPpvgddqgwHrZhJlTlThpWJMZp +SdjStScTWTwwvwwfjRhQPQQQDlLBGpLrPrLrLc +gCqJbNsVsNMgzMJnnqzNlCLGGlZZPrLLlLLtpPDl +JsFJFMmbJqqnJbhSHdjWwjtmHWvS +zBFDGGbNzDWRbDccsWslHlWWsJcS +zMVqTwzPfVfVMwmlcZTZZlSmTlmc +MrMvMCnrMVMCPrPnDFFGgQdFgRdzznbd +rJtJnrnSShJgcCsjjNNMSSDzRmzm +HWDWPBPDBfFVBffqplvlmNlQllvzQNQqlN +FVGHHFVbwBpBPwFFGfBpHVDgrcJCbZcLdCgtcCcJLJrd +MGHGGFFqbFTGmFwLmQsQflFN +WcvBdpjhdZdNwdZwLZ +vWtgVcpvjthtNcjntDhhpSJMSqHzqTzqCVHTSqHPGT +cVHZfjfZMcrSDQMJRCBCQw +PtGddtslsWQDBdwCDDdw +WsvTFnshPTGhGhhlPNGTCnsjgFVfmgfHZfVHgcHZVVFmFV +JFFqfJBgrHBffVHlsBFqfWNgjTtztNnttWWvWNwzwt +hGZbcBcZZSQmZLQRTbvNttTzjtTvbpzv +cmmhRchPZhZSSmdmGPDDdJdBVMffHlqlslfF +qWwTNwNHMHNNMRqMdRMQQMHLmmvzrTmrzPvzJvZvZlvzjZ +FphBpnBhVBSFvLljzZPpmrPL +nGsBbssbcbdlwggdNl +RLSRTLSFFFLPSWpzzTJdzsQpbd +DvqqcwVMDDcfrrnwDcwnvCdpQQphJhJjhdhpzsJhMQ +fGcvDZffcGGZDHGrGrtJRPlPmJSlPLRgNBHg +QlFFmGQFDQrrWlRlWGrnQVCLNvvPwLCwBvCcCcJCLCCm +tHtfsjSMCNPwzvCf +MjqStqMHsMSgjShjTttgphsTlrbDWGDrGlRTlNDbQrQRWRbD +QbChcCJCbHQCjbGCjQfsdsrtTqrfTLrcFftd +DwRzVzzZnzZRwvgRhRWtqsLLWtRdqLLdqd +NMwMzBVVPPSGQhBl +ttTPHWdrJjCdjnFMtLLtLNvQltLh +pSDBwZRBBsgfDGGsGpBVMFPQQlFMFQQFQfNvLNfF +PsppZzBVzwgDwBwwgpSSBssWjqrdCnjjHdmCTHznWCJJWn +WcdHdPcdZrLPDPBQDg +pMjMMqfmJlqNflMlFNRfLBwnLzTTTDJJwDTTGTLJ +hlhbqpbNNbVVdbZtSB +RDBWGRDnzBWBJDNBttSLlclldtQQcTTLFF +rTPVjZZsCZrVhdFMcgLgwFSgQh +PsjHVffbsTCHrCvTPfDJGJHNzzNJWnnnmzDB +LQdFgTLdQjVsQFTRBjMZrmBjWGMGSW +flvJJlJpbNnppCpMGGfBBZSZRfFmGr +NNbNDNlbDpHlbDDplvzvnCbzqsQPFQsTTccsqdQqLgdHLwQw +DnGDNDTFdFwDzCZZRmhThCRRRv +SgrPLrrLsBPbHBCmtVZVCdCcctHH +rSbgBrsqgsPppMBqfpPsLpPGlNGGDwNFNJWDldlllDwJMG +PWbvNWvpvJPnWDGqDjDczj +QwfFFVVQSMlDlQfFZhsHrBrhHHTcjnczqjzqrG +mwMSgfmDmSSFgfFNbmLpbRbJbvbRpC +lsggLLLDGldGTGBBhNTCwRwVnJnNCCnbRV +QQpWrpHtrHrpNRRJNtfbJCVR +PvQQFPzccvBglclNscls +NsszMMNGWLcWBhMF +gTtwvbqfnDTdpvqDftpnnntDZvLFQFBLmRWFRhJZJhLLBRQB +DwrpDbngprPWGllSNrSS +nCqdLPZPMMZLNvtGhRmGhGPmtW +TSrVZVSZVwFTgSVtrtchvWRRrtWtcr +gjbjBjgTjfgfVfHHppBLMnqLMDnqClsZJLLD +hrqShCPCpHHBVBGWQFVQGFGnzQDf +tgvZsbwsbcMbRsgccjDGFvGFfWJLLzFFQJ +TTZmMcgmbmWZMctbbtsHrrqqSHHrCrPBBSCPrT +HHHNZLGLpBpRSvWlGlqhPghqDGnnFr +QCNCMTJdjMjdjsQTbdQmmCQDngFqnggPFcPcnPFcDqcbDn +MNJfzNsfJdJjdzwMNjjTJttSHVStRtZVwHvWRWtZHt +DSbvDdDbbwHgCSgZPwpbPgmTTJhsTTChqTJssQssFmJJ +zzjMNNGMMRcNNhvnvFqmtJJv +WWffvlVrcGzGlcjLvfrVRLHgHgpDPSbPpwwHbWbBbPPH +FCCjjFlFtCjzlpTHtJsQTTcpTT +DWLhWSgDWWdSWLwmmpHHQTHcBTBvvwHvHl +mgGRhrLLgWqnjrfCNlzP +cLsslBlsqNNTHlTVNbLZZLRCQbZZdQdpbP +JGfJhhwfwBBSJPRdZddpZRQbfR +hWmWGgDhJrFhBcWsssWHvHll +lmmvlJFtMHFtQzVSRbPGzLJRgG +BcTcrNBrrwwqDBqNqwcrhLpLPVzRhPRPPPgSGVPLbS +TrDqcnsTcsmnvHtdGtMW +CcnDQpSDcnFcPBrmbPQGBsGB +gCtCfRZTBWbjPRbr +qgvHqgJhMfZTtvHgfTghJgMJDpdppFSLLCcSDvLLcdDwvLcw +ffFgGRMWSTGcnDgllDDpDp +dvSdHBrVSLNVLjdlsllcsDqpsZ +SHHHNrLJLvtNQJVvmMfGRGGRCJWJRwzWMh +JNpNDfDBDHVzwHHzpzBWVBPsvsFNCbmbqsFFNsjCmvsmNC +rnnrtLhnrrQZMvtFbWmqtllcFb +GQRdGQLLhMSQhZLZdgdwwHzPDzSVWzVDwJDVpz +LdcGjgdcrMDSFGVfnnGG +HNsCCQFCPvFFBJnnSBJVfDVJwf +HHFRqHPpNppmQPcpLjzrdgtbgztT +GlZZbclGZsDvlGhsShRnCnMQtjtQjnCQsQRM +PggFVcdFNFNNVVFLPdPdrwpWBMMnqMpnttJMnjMnQqtqQtqq +FdgcdcLwfTmSGTmhlbzG +RGvhGrLhhRhlpChZrGSprBdPPHJJSBgSSHqBWBBffH +mQmjmwtTMTVLzHnTPWffPHHJBf +jMmmwMcVcFLFrlRshZbCrF +SnNgNgBlNZSZdZtMrlnSnnQtjpwFwpvFJwFqpwSbqjjqGRpv +CLCcWHLhLTzsDPcCWMLGpFJbGFwsbvGwJwjpRv +zMCTPhmHWzfhQQmndNllNrQg +dbdBdZrQsrdrGslrrSpLvwHmlTmmwScTHv +FgnJqLDLWqNnNpppmpCSSmCJTw +NNhhnRNfzMhgnMDFfGdGLbBVVdQRtPVZGt +BBQJNTTzTcfRhtjhffqDDWCC +vZnsLsVLSvPwPFFnwPlSPgZWqGjChgWCCWWCMCgGMh +srLLnLmlPwrrPwmwwvlRqzQRJBmppQTTQpTdBN +PLDpZGpWbNGWLDfQmsQDwwsmhm +vTzMMbgCfgHQsmQt +VMlRznlzVnTcFzbMcrpJcNrJdjdpZrLdcZ +SftvFcDSvDHsFtctMSvbdjbpqpRRpRTJrMdrrb +QzQZWZnQgQZwBBwsJdqPjdjrnTpJjs +NGmwmgszhZwwGGgZGmggWLVSVHlNVVtDcDltFVVVlVHt +WCfFBfBHHjHHjgHBjJFVcVRwQMbVrRhrJbRRJM +sZMsDqzZPRrRrVswdc +vvTzDzpDTvpDvZPvSnNZZlSHMCHjjFtWmlttlCjmCF +hJZwhrvhBJRrPQPwRRZLllgLqfcqpTggpcTWMTff +HHDzMztbVgTzNpgf +nGbmtjDMFjDjCHbbbHHHdBQQPBrZvJQRwvwRPZQJGs +NNSrMSHRqWpWNNrNMvLffTBBDmsvcmcJLM +lwPPhcddcGPlBDTDlmDvJJsv +bZhzCdPGGFzVVPwVwbNtcqHrpnpZptSZqRrt +GvvSWhmhWBNcBDNc +FzlRRTljjRTjRRmZfbflRTlFFrrMrcBcDVqBVsNDDJsMFr +bttRfzfRHzjlmlnCbTtzbRShgwHGGvppLdpvwLLGLLhd +MHGMWdBFFNsFFHpWSFddMmqVmVBggmlVfbVffjgZml +hcJsTTscvsLDzDJmqVgfqbqnbmfJbJ +PvRTzsPwLcwCprSdwdNW +qfJnJdLpJzrcqCrCzcGfpRSSVBPRSjSSllTNRBdTRS +DbsbtggsbbsghhgvnWWSlVjPSjmmPBtjPNlTmS +vHHHHDHvZHQvWbWsZDgWhDwWzpfGfzfcpFJzczwFJrfffnGC +sQvsRQsFZvfpGhjhQqjpZvjGJHgngPBNHnCBJBCmSBmBNG +HTHwbtdTDDnCTPTT +zwMlVdzbzLzMWvQZRQZfZZlHsR +QhzWwRBPHgFrWWrH +SDgJCCDCsVpMMqTtFpfpqG +gJNCCddSZNSlljQzPPNBzR +dLzVVjfLGCCdRPrdmBtwWttr +NnbNsbTHJnbHbSHlNQsNtwrJRwBMMBhrPJWZRRtM +QSslpFvpSSsQPFCDqqgzcjCj +fcpGshsfNcNZsmRjNqCtnFgbCgHrrggmrn +QvzBlBBQBdJTBzBwVVMgbrwwLFtLtgLFHCHrbF +dlQQMBSSTPZfPcfssZNC +gNGVMzVpVVTdPDWdRdNT +BfjbnCBjBzffHrbrzBDddQWTZZQTTJTQTHHS +zrFncfBjcjnrrlCLwFgpmvFmwGmVLh +MbngccTfWgbWcTTzZghmLshhLRttpthRDLtf +CdFdJHCJjBvBSCNCNJBjjdjpsPDwDtwvptRPmLmzRwhhLR +qJSCCBFHQBFFldrVZZbggnGTzcZQ +lPrpppllcwwpHprppNdfLbQJnWdLJnncdN +tSjjjSSDGgghRbbSTfTbTFTLQn +jCBgDMbBMGghZzCZmmlrrpwp +FhCDFvvPwCjcLhDjhnvjnsdfZTlflQlflLsppdQfld +zPNSmmHrSSHWBNSMMVGzfGfZTZQZzdpdRGZR +WSNVVMMVtHSVbMNWBHqmwcvhcgwgvwtPvgtPDjtw +jSSSjzZMmgSzzwmZBtHcHmtNdncHtnpNcn +VsLsRsJJsTfRVfLRLJlfLlWqNbDcddncvpvbdvcnpqdpdtHq +GQQTsJGGJLlRGJFWffWLhgZwrZBZFZrhtBjrjjZw +ZfzJPvPnLvRJRfZLDfjfrBcqrgsgDBrcrGgslsms +SNhpqSNhpVTNQSMNgWmrlccVGBBmwrBw +QHHFhhNdTNHHfZPFqtqPRtjq +PMZSPSZZGMspsLhLRqRVzfGjvF +tcwwgcgbcbCrtbbtmQQcCqRffFLhRgqjFjRfhFqhqz +CLQtcbcmwmbdrbBrlrCwQTsTPsPsZNBPNWJpZWpTss +lMTrcHrhChWnRzJrznnr +DDJbPwjLJpfBQjPVBpbsGVGVWnZnsqnZsnzsqZ +wJQLbpPJDLfgPbDNCHNlghNCMhcNcl +tlVZhlVWtnBltVtssZBBbPbcpdPwbPWfvcbLvbbb +NwCTFNFDNdSNPpLpfN +CGwRjwDjzFFGRGjjFRjlBtZqMzVVtVqhMZMBZn +HhFdMFHhgrdjcZtZjr +zvvQQvzwzDMjZTjtcrTDtt +BwMwSvQSVlzQlMQzwzNgGHPGGHFCCCgGhsHLCS +zMVtBhhVhhDhtzBtMTTfDrPbmRRmPbQmrQbNQGRQtR +vLlJHgnLpDvHHvHvmPbSQbQRGmJmPRrb +pspwHClCwqplsHqDsMMTFWsWfjzszf +CmmjLwWSWGCHCjwSmStJBgQcccBhwgQtgthQ +WZVFTpqWsMsZpFddzszbVzJQBnRtrQthchdBgtgRtdrc +bbsMTWsMVsZqNZMpqWDqbMsCjvlCfjGCPlLLPLCmSCfCLN +VzsjjVGhpjJrJHCppprt +WtMnqtWdSQDtMRSnLNHHwHwQvrJrJCPN +tTtWSScTddBqdRMmlsbFBfhVBhfjjF +gLMWzdTgLFQHdlMgMRwcwhqqvPcPhVFRDF +tBnGrSCZNZCrtGBsSNGtBPhcgfchqqDPwVPRvNRqwN +CmrgstjZngtBzbjJlQWWHjjM +qttwGWHtVPzJJPqbmb +NrRvfTTghNrpLrrpLTrNrRrhvJmzmzlbbVVbdbdZlDdvzMPb +rfcprNcfgpLrVNnnCcnnscstFGCF +ZZhTfggZsbshGrfshMrNMCSRMMWqCqMNRq +TVTJPDTFccqMCcJw +BBLBmLTLDHFvsQpfgnZhbQvG +ffSrFvVVmVCQSfVDFzDvDDmmnGWCRqGRWNNqlttnRsNtGnWW +PgZQgPJJpTpTHRGtNRGWqZMWWR +wdTdwgbPJTJgTgLSFBbrQvSrFrVS +ppssshsscCVCHhVWVpznnQRBnZnBbzczFPRS +dqqfJGWttfWGlwwPSbFbZnRFPFtFZS +wGwdGdddLfGgMTJfwLMlJMpTCChjHhjTHpjjhmsDHmHW +PZQBhRPQBQrWHFHqHFHCqh +STQSvvvppzSVHJJFWjHC +TTgTvbsbszcNnnvbncvRGPBRtRgQrDPLfftPPR +dMltttpQhmQVZdmhsdrvNCHvlWbHWvHCWrlr +PzzLTGpGPDzFBzqFGFqFvHWHvRJbbrbWvCvjJCLv +BpqTBzpzfGGTTPZtSddtQmVffSst +bwHbRZldhQQfDWWGDjBf +CzvgpsNMsvCvFvpszpnMsFgBTDBDWPnPVJJZZDJnfjDTff +CpcLsFrMZbhRcdmt +HgjpWlhzpWjhWTQPFdPBRQzTMQ +JsfwrqLttwJVLGhRQGGPBd +CttfrqDmDDtCsbZCHjhZHSHNlgcW +QSdCWlCRhWRdlrlZrDssZsGDbv +pjPrpjqFNrZNGnBbsNDG +wjjVHjfLQRCgdLrC +PjMpRdBdjMSGsjpdprqtwCrNGrrNlthhrG +WQzDzLZDgzZcqlqqrtJclJnh +zbWHQHDfDWZHfLZHfffWVZpRSPpdVvBSPMqVMPjdvspS +TMBJLTJlFHBjFFtMGngpvvpgvQmtNSNngv +bVhsZswRCbbVZWVfVZwVSpmSQPPvNHwPHmgmSSNN +dCCVZZcbWVVcCbbfsLrdjFMJdDDHBTMrjr +vNWcTWnCqNCPPjhhHsQrfgszrTJRQsfRQD +wLdwMBLFBBQJpszJBqzB +lLwVmMSmttVMlSNqcbcbSbNcvHbh +PVfJfDWrPVPPLcPPFWcjPrqlqqQsljRpplqBQpRvSQvs +NdggMTCChMgdChNmdtTbtmsQSRhQslhlpFRpFwllwQvw +CdnGzbGbgMGMdTCZZDDJcZFDDnWrPH +fsshhnfLZSvcVbdcZVJj +RCCSmDFFpRqHQDgWvbGjgjDdbG +pFmFtCSBCSMBBLwrPsBPNlNB +fWWcwbbwbWfGCPgPfvbwgvgcQQqQLsGLJQTZHHrZRsrLqlJs +VnszmsDBpMFpzNFlrlRLRRHZqRHr +VpdzDMNzNDjpsdzdnzDcPCwtWCjhbthvfgtgwP +SPQtSWDLLltQQctHLSBSWHlWgFwhMRsgwggrFJPgdgwwGJhJ +nCqmfVqfVjTznCMhsGRRRgGFMffw +mCnNTVzVvjmqNtlDtbttDlBM +LjctjtppFWmgthgs +nBrNvzTqlDJlbbZgvmhMZVZb +JJrnTrrgGDqDPwwSPHPpfjRdPc +sTQmCmmVqmJHSTjGdMMfMNNvNHvc +rFbzlLLWWPzwlWrlbwzrWbRvdfFjdjpvjfFNNMccphCvhN +rrWzrwzPBBBCZTJgZg +gffvjftWddzZtbvdNvgZLwBBMJLSWMDMDDBRWRmS +PqPqpqcCnCpVqlClTQQmPMDwPRJJBLLLhS +VCGqlHmmHsjtHNsZ +mmMlVllWmhmmBzzLGMWlBmpstptPRRZpPMFJSpRsFRFs +DgjnndQcNTCCCDNcdSRSdtZPfwfwJSJJ +gQjCQqQjHNnjDCgHNcZGZLhHzrLVLGzlrGmb +JfwfJpBgJSMphZqtqDDG +QcQrssrGCcMCVcMc +RnljPRnPjWbGRbjnjbvmSzwHfHgwfJHzdLFSwBFW +sBjbHCBCnjvsJCHBsbvwwJGfRNFFFfFGTcrVFffNHRTP +zDqdpqMgMtgzthgDtQmzGPTVSTVrVGTFSVFFqNRF +zDLdphmmLhMhDhQdlzgLLbjCnWswWWlrZJBswCJJZl +FMNrQFgrVwmrpJMwMTMPflbsHPTtlSbftSjCbC +zGnGnhnGzDqRLnZLHNHbbbHDlltNSjCl +nzddcRzzBnRRvRRhvnQFpmpgggJVcVmMQmgN +CCpMlhwwpJpdBlsdcjvtZDFrtmRqmDrsmv +gzVPbjSPfSPTTTPnWVSbbvDQZZDZrFWDvFDvmvQQmZ +LTbLTPgnTzLVPNNGnNTgVNPlGdHHCphMwHMwjMphlpjccl +rMMrqcrmJqJqmCsTPWWGGPzPlPPrGL +fnwqwwZwRnVlWWnzWBWlDP +jvVHvqfpJmhtHJtH +NLMVQjRNTJCTJtZTJc +DlGlGHvFHGDgcFCtfhCJFtZc +DBHGGGSDvGDPHWBGdBbSvgWDNVMjLLRnmNmjPLNPNcRQVnjj +tsGdTJdJtNllzjGRzm +HZvvDLLWqbBBMRMRNjVhHRmn +vZDCvqqgBDZZjbZDrWqBvpdpFpcdpCJcPTSJJtptpP \ No newline at end of file diff --git a/src/days/day03.cpp b/src/days/day03.cpp index df74625..c7502cf 100644 --- a/src/days/day03.cpp +++ b/src/days/day03.cpp @@ -1,11 +1,110 @@ #include "../aoc2022.h" +#define LOWEROFFSET 96 +#define UPPEROFFSET 38 + +enum ECheckType { + eIndividual, + eGrouped +}; + template struct SDay03 : public SDay { //Class constructor using SDay::SDay; //Solutions to both days - Output part1() override final { return Output(); } - Output part2() override final { return Output(); } + Output part1() override final { + return readBackpacks(eIndividual); + } + Output part2() override final { + return readBackpacks(eGrouped); + } + + int readBackpacks(ECheckType checkType) { + this->input.clear(); + this->input.seekg(0, std::ios::beg); + std::string line{ "" }; + int total{ 0 }; + + int counter{ 0 }; + std::string bags[3]; + + while (std::getline(this->input, line)) + { + + if (checkType == eIndividual) + {//Checking an individual bag + std::string compartment1, compartment2; + for (int i = 0; i < line.size(); i++) + { + if (i < (line.size() / 2)) + compartment1 += line[i]; + else + compartment2 += line[i]; + + + } + //Find the items that appear in both backpacks and get priority + std::map inCompartment1 = getMap(compartment1); + std::map duplicates = findDuplicates(inCompartment1, compartment2); + total += getDuplicatePriority(duplicates); + } + else + {//Checking a group of bags + counter++; + bags[counter % 3] = line; + if (counter % 3 == 0) + { + std::map bag1 = getMap(bags[0]); + std::map bag2 = findDuplicates(bag1, bags[1]); + std::map bag3 = findDuplicates(bag2, bags[2]); + total += getDuplicatePriority(bag3); + } + } + } + return total; + } + + //Function that take in a prefilled map and checks through a string for duplicates + std::map findDuplicates(std::map& duplicates, std::string backpack) { + std::map newDuplicates; + + for (int i = 0; i < backpack.size(); i++) + { + if (duplicates[backpack[i]] && newDuplicates.count(backpack[i]) == 0) + {//If the item is in bothcompartments + newDuplicates[backpack[i]] = duplicates[backpack[i]]; + } + } + return newDuplicates; + } + + //Function that takes in a string and generates a map of all of the items in it + std::map getMap(std::string &backpack) { + std::map characters; + + for (int i = 0; i < backpack.size(); i++) + { + characters[backpack[i]] = getItemPriority(backpack[i]); + } + return characters; + } + + //Function that goes through a map and returns the total priority for the maps + int getDuplicatePriority(std::map &duplicates) { + int total{ 0 }; + for (auto& i : duplicates) + {//Add the sum of the duplicate items + total += i.second; + } + return total; + } + + //Get the proiority of an item in the backpack + int getItemPriority(char item) { + if (islower(item)) + return item - LOWEROFFSET; + return item - UPPEROFFSET; + } };