From 02973bde28a8a23d2657accda9b76bf9b6ebf61c Mon Sep 17 00:00:00 2001 From: Justin Wernick Date: Sat, 3 Dec 2022 13:59:11 +0200 Subject: Day 3 --- 2022/inputs/day_3.txt | 300 ++++++++++++++++++++++++++++++++++++++++++++++++++ 2022/src/bin/day_3.rs | 100 +++++++++++++++++ 2 files changed, 400 insertions(+) create mode 100644 2022/inputs/day_3.txt create mode 100644 2022/src/bin/day_3.rs (limited to '2022') diff --git a/2022/inputs/day_3.txt b/2022/inputs/day_3.txt new file mode 100644 index 0000000..a29ec79 --- /dev/null +++ b/2022/inputs/day_3.txt @@ -0,0 +1,300 @@ +vvMQnwwvrwWNfrtZJfppmSfJSmSg +BzGqjlBqBBmztHNFzDHg +llRCPlTPPqBjPhqhlBRBClhqWcTWrWNcMbQbdrdLccccrnvM +wMhwbTWpQjbpWHMQppzTHhjtlCjPSSJCCtlqRlJVFJFt +ggdvvnvDgdDmNcBrrcDntFRFqHJJtSJqvlVSRlJq +fggNNffGmcBrmBfcDzzzpHbsGTpszwwTbp +BPdPPBggrPtrpbtvPBBdgrFmhhQThGGlbbTZnzZQzZfn +ccjWRJVNcTGmnWWFmh +DMNmsMHwRNBrggdPDPdt +TfsfHLQbBtBFQbQsBmPwwlnPGZFwwdwWFZZw +MRpcvJMJVSMrVMpVSvhhnclwgWwDZgWgWgWglwcG +GCzjRJjVjSSrvfNQtLmQNsQbjB +FrSPFjtVvwsqSwcG +hDHdWDngpgZTDgHzzHwNNqlwNvZJlGqcQGsl +wDzLTDHgFffLtRft +CnCJNVqvCBJBNZmfPcPMcFLVcwmd +HgzjHFghSFtrLfwPchPM +QDpjgDSQlHHlDQQRzRzsBRRvWnWvJvZnqWBJNF +mGHcFPFqzPtcfPwDGVVpgLgSlgBl +rCvddTrnsbDLVSDwjSjd +QWhWQThswssMQMMMvhTzPqJzmzftHccJfHFhFm +cPbNpLVFTPbbFrpTLQBzqqmgnnBhgLMM +vvSwWCZCRZCDZtGwzdgWdQmzqgnQddJn +vCltGltCGmRRmCvDjjtHFpbcFfbbfssbpNPpHFpH +WLLQMWZLSPMPWmrwhnjhZZhpHJHljBDB +csbtCfFgCftGljHwHcBnpnJR +tsvgszNtfMwPzWqPrS +NbDZrbrFQQqqQtQqQDtTcBvCLBLswsZhscCGBZ +ljmWRzVRpbndMWmmfdsTsCBsGwTVVVCGCGws +ffRpnllHRMfdWzdnmRNQNNSFQQFNbrFHHrNH +LccGzWNjcvNLGTmHNsNLMlMwMpMPGlMCwFwDDGCw +fZZtfrZgrfQSnnnSnJRCglHpCwwHwpglDClFMw +SqJQnffJRnfQQVRhrQtrhnThcLhzNzHdTjhsTWzjdmcm +QJQwJMSbtbRgMQMQVZpCZsrrhpZBwrLLvs +qCNPGWdqhpphsWrB +DcNPNnqjdGDqjmPGGJRFMQmgtlQmQJCSgb +blTRbDnHRGGBwnGPCtFPWzVCDvFWtL +pdSJprqhhZSdqSdZNhVzZWtzLVgVPvzjLzWv +rrsqsmrMpPHlwTsRHn +mbNhgbRSLmTwswFm +vHjHBWMHBzMqWZVZBzHzcwwwdcFLcpLspdzwpwQd +HfMWMfvjWtZHqWDlhSnnnJNnbhslDb +lwsvPPnqlwwwsPcHTgqcRcSccmgQ +CVWBWCFpFzWfFjWjhNSQJJmcVcHRZJNTSc +zdhfzBtfLLtfFClbrDvsPvtPbnmv +PntVQbDnQHcDVvhtbtDhcbPcFTrrNfjqmmPTTZqMLZZMjFZm +lgJCpCFCSCGCpllWMfZqTNNZrMjrJTTM +CSzSwgFlzsGBzQcQhsnnDbVdtc +THzqvrVrWzhqhWwqhTbNNDRtFRmmpFDDVsFLLsdddF +MbZSSScZSGCJCjZlCjdPmpRmFLDtctdmFRsp +GfJQlnZjSMnllbJCQbClnZQrhNwwqhBzTNhrffqhqWhTqz +BdBdmDZHFFbrHHStPSRtPCzSRNDS +JGGpwqLJGMTLpLlMpqLhJtzCCSGQSPzNNczVVPVzSV +WwpllfslqfhffLwhfJpJlqlwdBmZnrdFHBFBBmNHFsFmdZmn +jZfQZnZfnbRfjCnfbSSmVpqmNmVpCqlhCqqPpP +MdJMwMvvLDssLtFMsMtLDsvvDRmmmPhWzWzphpmqDVzPDWNp +TsLdMrvRtLJtGdtGRRtFTBjSBrScnSZjnbcgQgHfnB +RZfmlRlWJmWLLRscrslJqvvMdVwmddvPddQPVDdDwz +GStFbFCbntbjNnjFhFvdHfhzHfzzQdMHwPdD +BSGpFbbjbNjnNNFSbRsLlWqgrZrfRgsBlg +ztHczmrmcNNzHsPSTwsPHSQPQT +CFCRjlvbClCjBdPDFQdwBsqn +llbRgjClJCVVMMCssfmNZWszrNgzGL +mmFldllVlmtdWFvPPFBcSSBW +DZzZGzZswQZHwQZjZzWWTSSvjSdvPvvWjJTS +DpQQggwzZGdmbCldgVgf +PJJvhqzVGbTFqzqbbGTlLmrtrZMnnZnntlJnrD +fNwRcQBCRNddNgLtgDnttqrMMtlr +RfRdNWQHcqHscdfRdGPFbFPpvpVWWzPzVS +DRgjZRRDggTfjfRvwWzHGGHPWDswvv +dhbmpcCmchgCpsGzWPdVGvWHwP +hpMMMpCQMnChFgNRQffTRrSN +gfqPCHWtPMMjCtffgjQWGLvGdZcdLLGZcLFGZBWG +pJTDsnnnvBjnFwvj +zJRpTbNrTSppRVblgbljMgMfCfbC +fGrGwqggtbVmtzbf +CTMjNQcJjJTBNCjMNZFNBcCZHbmWZHVLZDDWVtDzzbVmlV +hMvTcNMFMhQjTTBFBNMhwpspwgnGtvtnSgdwrRpG +RfFdqPdMMGPVgWmNVN +QwrTsbnSsSQpwlSSbNNWDmGLVjjmLWwNVB +rpcclTCprmZQSbprSTpRRRfqMfHHCHfhMhvFJM +LnJJsMtLbzsPPVPJbrTBlTWlfRfqnTrrlr +VDHVQNFGgNTrSjSBjq +CHFHGmvDGdZZGCQZVDgDHVbwLLwtMwwmJLJbLPPMbczt +qNNNBllFBzFjjzwGqGgLrWgrtQjdmmtQmQpp +ZMHJCPhMZRsRCsCPsSJZLmQdQgrtQwQwQZwdWg +CnMPbbRbsPhCnbfhMPRPllnFGqwTTFzTzNvBGBGc +wZWlBFZQgBzTzpZwBlVpzWBWnNMmnMvMcMJMmLGnVmqLqGMq +PdSDfJbCHsHHdJjsRRhjjPjmLqnnrLMLcrnLvdLMNccvGn +tSJtSCtbJhDhtzlFQZlTZTFp +TNqZDqmMDZNMFSGHjSGBRBdN +CrrwVwsPjjBHddPf +rpWggQVspQWcgtLwcHZZzDDMLDvvnnMzDM +lWrWmPwmGlZwZjdLZLzV +cFcDJhJnmqBqDCRpZzVLNsFLjLzdds +qJchTDCBHDWglmrfWPHH +RgLRnTJWnfHDcQQBfg +bZpNwdwbdMvVPsHHJMQfSSfP +mVbdNNdrbCzZbdZvbWTGrhqjTJtRWttRjq +TMtqqBJLrwqrZPlHHGhGnlBhzv +bFgNcpDRnpgggjCzvWDWhQhQWQHHvz +jnnVgjcgcTZMJqJVtT +dVSjmdHrfGPddrQgstFgzsQfsMFQ +hvJJCCJDcCtwBVFQzzBD +RWCnTvWTLRnJJLJllWhTLSprVdNZVGHGNGGnrdGSZH +gvMSHFZtBBMBMFZHzjnqLsLGMCzRWWMn +QJmDrhbNDbJfPQhDmQPRLszRlnjCzzWqrRnlsL +PcJVhJbJJNcNDmfDmjJmbhTfBvpwVSdggtgvgSFZwgvtgpdZ +PBClRHHClRlFljllZSBBBllppVGDLpZVVVsGpmGcNDpGLL +MvNwnbMwccVsswDG +MqnNbzMMrQfnqtttqfQWQQnRdCSHgHPglRFBRWlHjWRlCW +lldwdfSBWphHBggZghFs +DjDbDVRzDmLRzRLGJjPssrLZPhdshFHrssTZ +mvddMzvmmDDvvwQqWftCfqWqfM +gpTTwNWGWMSMgJjnvpvvJbJppn +lQvmLFdfrQzRFctlrLdRLVPnhPPbVDPDfjnVbfhJjV +FLFqccvmmtcQtrmQccRFLlRLSSWBSgTWNwsggqMBsqWGHMNG +PjPtVQrPVjrVPLLDQVFLTTWWqbSZwRwzqwSbSbbbwFSq +lBnGJBnfflRRNZwbqb +HJMGgmfpRMHGGdgncJHLDjjtVDQctLCvQCjTtr +VvmvjRGwRwvhmhRvvvVCCTTJjfWqfDMMcJlcCD +NpNbPfpSnngZbbLMFJWTMlLFqJJDMD +bNSfdSHQZgVQzwhhvRmQ +MhmHcDhChhcPVMDPDPQdFhQHnbNpZbZnprnrmNnjNbsllbnp +WWqGCWSCzsGbbGNgjN +LzwqBLSvwJCLPVMVDLdhMP +mNVLLffSLVWdZCcFZCZrSbGr +glvcwszTlsRDrHQCZFCvGH +gTBRlJnwhzgTgsTnggslsJRTpLNmjmNNcdVLdhfpLpdLVmLc +pCgfDrDrgccfppmDnhHMGqGbpHHSqzGLlqHS +tFtjQRPFFZRVNRcQGbLzLFMSGzSbWLqH +QRNTZjvjTTwtwNfmcTgfnCgnnBhm +hcPBhqPzqWPccHWHHWqnPdssPVfFFmZDnVDDms +NSLNCTRQZndRmDfnRD +QSGTGbjTSTJHBlbZZBbh +dgcWgVgWdvZSbbRtjLRZZZ +MMDPPfTnPTQrFDMpHzmmLztLnsszRtwbtS +rDfDqfHTpCSJqlCCGq +bjsgllstBbpNpslBpdBgqljgGwzJzDzwLGGrwLQQdJDwGhQh +nncmnmHHnmWRWmPfJCnvPRMrzvDhZZLGQwhDLhhMzZZZ +mffccVHRRPTTNlpNbNjJVslJ +DgPstgPtgPNNcjQQrtPJJCRSZTwSGJZZCZCJGD +dHVvpzdBBhVqzWqvhvHdzGSZlTRCSRJrwSSCwJCWGT +zpvVVqMBrzqrhFBvjbNPcPLnjcQtMcnj +gBcmTCFghhCCBnBhWWwFbwLdwHFMLMdp +LVzlZzPPMMzWWrwH +ljqjsGlZPPqqlVsPqDVqjQQctNTnRcNLtCNmmnRTRthBGG +LPRrrBNNjLBRJNdrGPRBfBrLwFqmDbdbTbTgmmgwmttFwtmH +QQcVvnQphlWsCQCCVpnvptTJgbtqwHDwbJtJHFsTHw +ppcJVQvpvMVMCvQZQVVZCCSRZPSjNRRZBPPPPzLjSLGf +MLtRnjQsRMJcDQJnSrsfqVVvGwbbbqgggg +WBFCNlFFFhFBlCHbplFWdpWZfVqPPwqTGdqTGvwrPVvTqvTr +HClCHzFzFBhmnjtQzMMSMnbD +sVnMCsdlMRcMFBGz +JvwwgrJDfgDmmggQrhNfhQQftjFrGRRtZFGBRZFHzjGcjrcj +PBJJvgDPNllPddVCPl +fmmRSnfnMnFSmMmmzTDSBFHtlJJqHJJqdHQdTCdtCCdt +WggGpNVVgWdwwHQtlGlC +hjbWppbLbLZLjVPPjPLSRRMvDlmSzDzBSnBFZf +nVttMPnPLjnJLjcnPVCjJJLcssfggBNlffgcNsWTcGcgNsBF +HQbwhmDrRrgFsWlQGNls +pZdbGzGrGpVttPLttv +LLbMrMHLDdWhmgbqqt +jGSQZQTpQGVVRSlQMQRljZmgmJBSvggvBWhJmJWvddmt +VjlQFGMVrFFrDrPw +DZVDwGZlJlVlwZVDzNdqfjMDnjqzNnWf +pmtpLRQFhSFpmpRgRtHNFznNdqWBjzWfnBjMWf +rHRrhStppHdJcGJrrssCsV +pgQqHwgPcPCddCjdWtdp +VfZGVFfNVhZhzjjjLz +fNNBBnGVNfBfRSRjBRQHJQTwJcJTgHPwTngr +MZdlzWzthMgrwmGmqZNqNs +VvJQJPVDBJQThwwNsRqsvRsHHm +BDQQPTnDDBQQBVfTBQPdFctzzdtztMMtnhcWcd +LjWjDShflZRRcZzfHH +srNwQPBsrVRhNmRGHzmM +rBdgQTrhdPndQTrsQQsrPwnTpLLCWDpSCLtCnvtSWpJjDCvl +gSlvDwCvcmcTQTFtRMjWHFVVHwtj +rbsphZZzBshGZssMffTVRFfFpWpfTH +GZNhZBhPBzTPNLDcDlCDCJNmlg +smZjGfvjbWWffQtf +dwRrdlVdDdgDbNtgcgQSNStQ +FdFVwdblFlzVrlwrTlndZHHZGhmLhhssjHhMjnjq +QFvQVFLLgVrFLBVgGhTtllPvmHRRGbTm +hDCCNCNCJNzWDZnqJDzSNCTnbRttHGRnccbPRtmmlmHc +qJshNMCNdVFVfsLB +FcLZZPFjdZcZMPcRjcRTgbpJlwbbTlmdTlGlwD +nrrNrHWBNSWvBqvvrhBqzStrgGnnmbwsbbJbwwJnmwmgJTlD +BCrrNvqWvSQPcCGZZRQQ +vPwcJblJzJbJcJFcwBSvJNdWRLtdsddGWWddWRWsMF +mDZmmDZDHVhfmjZgjVDfhTZHtsNptRsMntnWdsMnGtRntG +mhQrQDDhgqTTNfhmVQVBrPlBczSJbbCbCCPPvb +ZjbjLlbZjGqsgJTfHggrVvlB +tFDRFRnMFnnWtDdMdDRhzHfTJhJhffHvHTBHTgcfJV +nztDtdWzCCMSptSdFRRswZjsLbjwZmwqwGqpQV +vnvmmVnmVbrBJlzgWQWVNFzNHV +MwSjZhSwPjMwfDRzgWlNpWvHlgNNNP +CfSZjSfftwZDChDRSnccnrvBbbGrtBvctr +LCBRQRBQwRrCVLVWSrCSwCptzvhthvGGhdHzwppTTddv +mFnJJmnmFFFfPLNNmqqNJDpGnGtbHTtHvhnHbzvHvpGv +lMMPLqDmNMVSjjgMCS +zzPzbLjHLjfQPQHwwjddFNsNSJjDMsdNMFsC +BqqtmgDhcqdSFCdsqddF +GtcmrvhgcZlvZtBhtVgrvrvtnWzDnQbfnwlfWWRHWbbwzHRL +JfWHWZcMMdDLMPjRnCJjRbFgnblF +ShtBTSmBhTtqtfmqSTNvmjVjnFbFnnlrlqgCnrFnVg +vfzTTthppmdzPLHLWdGZ +tdvrvGgGTSScnHcjcg +zLLVfzPPcDZnPjSPpD +LfffNFLNlNbJwrctthWqNdNq +NdjJtfVNZnnFFdtfGfFNcvpbMDbzdcTbbzpvmcDR +PHMSHCHHWrRCvzDzDChT +BqPWSHwllSQWrLHQHPqlBBNfttZMjFQfjGtZtNjJJjnN +CpZtMCMQQpCVWjMDVjPVQsWWqJJhbTcddPlfhTRqchcJblhh +NwDSGNmGRccqNJfT +SBSSmgrrgGHnvSzwGVWDCzMCpLZtMsstLM +sbjHQsBlBQrrGjQjBqCRSnSCpnfngLnFhJngFfSP +zHVctHDcZtdJffnPpcSpFn +ZdwNMztdvzVdrqblvWsqHvBR +jPdjFPSbVDMMbqZzQWzQ +hFRrJlpprGhtlJGQzmCRmZBWQCHRQR +vThNplJpNhltNNlvcGDvwVFgnPwvSgPSSfjS +DhDTPQpTDmQbDQrrrWtWPJNNrrsJ +qqGjgwCgVRjMSRwMMGRGqjwvsNJJBZtrstvNBvHWHJvL +VqqgfjzfgfFGVjRggCGznhlbTpQchcshpdFlnDbn +DpTQTBbCZQVJQZJjrFllGdlvMPlMLqGBGvLl +hmnWHWWNzzmHsmWRlGGpdLgLHGlqvgqg +RzcWRhRnRnfmswfwtzzRWrDTrrFCQTCpQpcCrjjQCp +HLvpHvGcBTDFznvfqT +hCPQbPZPbjSbwwjCPChSClJJfzqTggTFDfsJngDg +StqmmZbdqrQmhQrrhZWcRcGBpBHWVcLctMWp +dNnRNbRdbRJMBMBVVThn +rNrsLNscFsCDjpwTMgBGWMGjJjWBVJ +wNcLpqHNsCprsfLFsHwRvPSSPRZRtRQSqtQPmP +PPhGfbthhBDVsTDtDqRR +mCmSNmqpcqjjrCScWRsZDpHsDQRZQDZDss +CcWzNmccrjjvqBGzzdPGnv +SDRmCSFfcSFFcfDmDBFSCfdVJhpzZjNJTNzRTvjzjhzNjTtZ +ngGsltrMWrblNpNTJJplJN +PGGnGsWngrGLQHHtHHHgWsHSBLqqfLcqBdVdcCDDBFdCDm +VPjGwhwVPhrnqhzJmQvQTQvmzBzw +ZBDBRbLLdtfRLlddLlCLCZMgmFJQFDcvzMQmgMzzJJFJ +LHLWltHlRZCtBVhVVHPjGSpphp +JqhlhdnnmfRVVSpzWLjzVLGpvB +stQtFTTrsZQPFQNNDtQgLzzSLvjvLGLBGSZGGWJv +DDDFFgDPbTwbTTJMCMcbCqqmmRRCnb +JbDWPDPPJJDMDjHPZHGbHGVZTBhrzBpdzszdTTphdNdWdrpv +RmRRqllqffwFtqwLCsqTNvpCsqCNqvdN +fmfLmStlnnfnRtfcnQbbjPjPPggZGVsMQMbb +WJggvGDJSwWgSfgvfSMGqqQHBcPjcHChcQBCssDHCTTQ +mlRnbrnbnltblwdnnpbLRdCCjCTHTjPTTsQcTrHHhCcj +bFLbdmzRpvSwfFFNWN +BHnDnQHnHMWLwzWPzD +dmlZCrdqLZzZVZJM +tRRtdlLCjLmqCRsrSLrvvRQNFQnbgRTQQNHTBbGQQh +ZrQPQWCrJnPdQSNTmBJNTHGHJN +zhFRfswjwhhsFttfsfvQftRtLTzmBTHGTBmzMLHHLmGHNTTS +hQhwqVjQwsdggrZZCWVl +VjfnQgVQjblChfjVJlbzLtrSLlTGtztHTtsTGH +DDqWQDQMWmDwWNwcqdWvpSrtLpLsptMprMStstMz +vQcddRdRvWcwWRmmmmddZmmfVnnngJJbZnCBnBhhFbhCgJ +gVgDnnmJdQVdJJgtgDjBsBhsBSPRSRRSSwccSbSqwPcCPcSC +HrQHlHFpQfTHzzWzwScPPCRfLbPSfCSR +TTQlZNTzlZNMWvrZMlpnhnVtnDDnVNtVJnjmhg +MCmmssFnZJcNNszfpvvrpvJzvwpp +BRRRWQWbSRGGRTTtZHWSqTrvDfgfdfrrwrDgfbvfzfrd +jRBhWRWTSRttQBZMNchNCsmFMchP +GBDncllqcSlNFZWBFWPjHVbw +LQphJlJzLCwPjHbpHZvV +hzCMJLMzTsrdrszQCCCTCQCDlqqnNmggqfGmgdmGgcmSNt +hFVVbqJsqhcnBRTRGBTh +lwdDpmzdNznzZBgGRRjR +HdmvNvSCmDmwNDFrMJMqJFCRfsbq +ctnbTcFTnbwSSfrrMLRhpJLMRdpwdJJR +vdGCVBmGVHPLBRWhpRLJJZ +VmQPHqvsPdlQsVHDftnlFTbffnbttfTF +LBJZHrhLThHddcMLVtcMcL +CPMNFDDMpGqFjjSPDPDqdvmdtQgVQQcQWcQgQQsj +DzFDFMRSFPSGTJJTJBwwRhBw +dpldqlqlRppFTHpbjbnLRLVnnGfjtG +NNJTcmhzvJQNgMJBwcGtjtGbttfhtsGGnhnt +rzcwmgvcvrBNvvmMgvcBzwHPCTWWprqPHqTFWdPCWDTF +BNllDRTNqDNvNDDLBcDvBCLVJrVdJdtrnrCHggtrdd +mppFMFjpMFZQZQGjFCdgrCrCdrvVGtJJCC +PZsQmfPphvPjSsjmPjfZllBwcNRDNcDqNNWbTclS +fjqZBSDSDwwsQwCDND +rrdMdjVWtTTPslsslFLTLCsJ +rvPWbvcmHjmdPbHvrvBHgqRRgqHGgfZGfHRS +ggTQgsgwFrTrggbMTvSdmjfCmmQDcmqjDjmc +nLZnRhNZnnNHZhZVStCcDqjcqmjSjH +RWGNnhzBnJJRRWNRBNZNLZhFMTFPvrTrTlsggPwSlFMWTw +RNmnPRnLGcQmzBQpHHjTltjtlfgspbsq +CZvCJwZMMCCMdFVcwJJsgTTHfsTlbfbgbT +SSVFhWCZdSCcWCcWdrvhzmnnnLNGDRDNzzLNGz +jPwfPwNfFpFNQpDjdMcjcrdddDHD +tzsRsGRLzhLhvqvhHMlqqV +LRBnRBGSnBSGsGSGmGtBJCmnNWZpPpTNPMwQMPNJFZTTNwWT +PCrStRPSPvZQcZPvqvfjSRWFFNFJFLZTTJTTVZFFGLFF +DlpBzBntHDzhlpGJVHLwTMFLVLTL +gptBBdgzpsBbpQvvPQPRqrdcCC diff --git a/2022/src/bin/day_3.rs b/2022/src/bin/day_3.rs new file mode 100644 index 0000000..ec2d5e2 --- /dev/null +++ b/2022/src/bin/day_3.rs @@ -0,0 +1,100 @@ +use nom::{ + character::complete::{line_ending, satisfy}, + combinator::map, + multi::{many1, separated_list1}, + IResult, +}; +use std::{collections::BTreeSet, fs, iter::Iterator}; + +fn main() -> Result<(), Box> { + let input = fs::read_to_string("inputs/day_3.txt")?; + let rucksacks = Rucksacks::parser(&input).unwrap().1; + dbg!(rucksacks.disorder_sum()); + dbg!(rucksacks.groups_sum()); + Ok(()) +} + +#[derive(Debug, PartialEq, Eq, Clone)] +struct Rucksacks(Vec); + +#[derive(Debug, PartialEq, Eq, Clone)] +struct Rucksack { + front: BTreeSet, + back: BTreeSet, +} + +#[derive(Debug, PartialEq, Eq, Clone, PartialOrd, Ord)] +struct ItemType(char); + +impl Rucksacks { + fn parser(input: &str) -> IResult<&str, Rucksacks> { + map(separated_list1(line_ending, Rucksack::parser), Rucksacks)(input) + } + + fn disorder_sum(&self) -> u32 { + self.0.iter().map(|r| r.intersection_priority()).sum() + } + + fn groups_sum(&self) -> u32 { + self.0 + .chunks(3) + .map(|group| { + let mut overlap = group[0].union(); + for m in group.iter().skip(1) { + overlap = overlap.intersection(&m.union()).cloned().collect(); + } + overlap.iter().map(|c| c.priority()).sum::() + }) + .sum() + } +} + +impl Rucksack { + fn parser(input: &str) -> IResult<&str, Rucksack> { + map(many1(ItemType::parser), Rucksack::new)(input) + } + + fn new(contents: Vec) -> Rucksack { + let mid = contents.len() / 2; + let front_str = &contents[0..mid]; + let back_str = &contents[mid..]; + + let mut front = BTreeSet::new(); + for c in front_str { + front.insert(c.clone()); + } + + let mut back = BTreeSet::new(); + for c in back_str { + back.insert(c.clone()); + } + + Rucksack { front, back } + } + + fn intersection(&self) -> BTreeSet { + self.front.intersection(&self.back).cloned().collect() + } + + fn union(&self) -> BTreeSet { + self.front.union(&self.back).cloned().collect() + } + + fn intersection_priority(&self) -> u32 { + self.intersection().iter().map(|c| c.priority()).sum() + } +} + +impl ItemType { + fn parser(input: &str) -> IResult<&str, ItemType> { + map(satisfy(|c| c.is_alphabetic()), ItemType)(input) + } + + fn priority(&self) -> u32 { + if self.0.is_uppercase() { + (self.0 as u32 - 'A' as u32) + 27 + } else { + (self.0 as u32 - 'a' as u32) + 1 + } + } +} -- cgit v1.2.3