diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 0000000..da8d61c --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "day-3" +version = "0.1.0" diff --git a/input.txt b/input.txt new file mode 100644 index 0000000..a30889c --- /dev/null +++ b/input.txt @@ -0,0 +1,300 @@ +hqBqJsqHhHvhHHqlBvlfpHQQwLVzVwtVzjzttjQVSjMjwL +gRTRnCRsFNGbTzLjwcSTMmSz +dGgsRWPGdWgZJqBBqhfpPq +HNCNJHCWJRRLqNJWlfrrrwsmlwGmmf +dddvLdLjdDvjvswlmGwlZQtjrt +dvcpbLVcvNJJHNPHSp +QDprSpLQRLQrQDmQcQFZjbbhZwdRsRFbbBss +gWGGPgNvJlgJzDlNGHCGPNZZgFBbsjbFFBwZwfhdZbZB +lHTlGMHlGCPNvClzGzJHvGcrMcVtLqMLcrrQVcVDrqrm +SrBpJFfldlFNslFJBZwsmwgVGGsCCVmZZD +jLtjvzLQMtWjbbQvDZZwGRJGgwggGZgv +MzqqjznQPqnnjznnctnFlSddPfHflhfBJFNdHd +mPNNGVCRngnSbgNw +WqsqlTssgvqvZWZzhsTzWhScdHtfJJnfbtSJwfczdtSS +sqTvhpqQvWZQLmDpDGMDGrgL +DQRcLQVLbbcbrFPcRtTBBBJnTZrrnmZTrMgJ +slGjjjdlhMfvdMQTvg +jlzNhWHhhWjHlwwwGLDSDtPQVtRzRbSzpp +DzDgfvzfDczfHCHSlgHLCmWG +PrpNPJtpPMBssmmVdmSVVr +PSRMwPnMpBNtNBTnnZwDqzQFfwhjZZqfhh +fzfBwhBJFbCwbwwg +strtgtrPgmPgFRsMdRnZRMFn +mrmLPDvGmmtSLDgmSqvHchhcHQzcQQJHBfBh +NsgwPPDgsPHqsTqqmLbLrDRhmrRVrbVW +lFpGFtfFlvSFplGFzptSGSSlhZbhjhfrmWbhLhmLbCZVZjWr +ccplJQSGcSSpVFvNqqsqPNqPQPTwqd +HFhPNNZGqSZrCDBVZBCB +RJTtwczTzCRVQrRHpR +mfgblfltwgwwmlJgcHNnGhSbFNnFsFjFqG +tSRqNRHpHnMSTqpcmrWWfqfmrCQCrW +lhGDtbgVVgDsDbhfldfwrzrfcdzwcr +vtDDhsgFBTNZFBHS +LcNpLLBNgdmHGmsBCrRBQDDwnwRj +hSWfZVhfPJJhfVWbhzbnQqQnRRRqPvCCrjvjwj +ztJSSJhzzSTJrZSbzzJTfzbZmLmggdmNMFNpmtmMGFFGNpmt +TRdFfLbTnLvZVlZvznQV +pgJGprJNhghhNjjPgPNrhNqqlVVlQVVQqQjfzBfQvZzB +rmGmSwJPwJprrNDbsfMRsdTDcDWHfM +QMpZZTtwMBttJMMbVqPpqLqbVlbqqN +rjCFGrdGRwdDHSnqflPVLqqVNllrfl +DHGDRvhvwTZhJWBQ +LcQCCpLQVhrdcFQCJrmmmwDwvDtJJnnw +TsZqqTzMRqZjfsjTTDjsNJnmnStRSHnnSJmnJSNH +sMMZZbDjZFdbVCFphV +FCcdFFGBsdDrbMNSmSdmQR +tVttHVLhvVgfTTtffNSMQRMZSRmMQNmHSb +gngvvwJtVVTvVvvvfwvJThhCzGcnsCjmCDmscPcGCsGsmz +fsnzRNZswZszPRZSLflPpDhlhvgWHmjWvJjh +bVcCqjbdjbcMdBrddrQphvHHmHWlggpWpppqJJ +FBTdFQGrTjLNsNtL +MSWWgMdgdbWbbfdgsPmddgCmSLZvSFvLQvnLrFNZvZFLlLLl +hjpJjGthjRNRptwJJqVBllnvrrlTTQFZqnTZnn +tjDGHwhHHjwjjJGpwjwjjJpwsdgffmbgMsmbDNcMcdmCPdsm +MlDrrgnTDLlCCmCRFgRSCR +HHhbbNQMccQFSNBmmpJNSJ +MwbMbshsswVbHQsbcVMcrtDllTlLqfTGVzLGrTlT +gSFzqQTpmVpQVpLFLrzJJRthlsQBlPsZsBhZst +rwrNDdbHdBhRhZbsjB +vvvMHwHcwGCwwNfMVSrqffWpSfSFzLmT +RNgMgRCCgCfPNfvNgVQmhPVWWjWjLLdLBj +JhJqqqwGDchsBVbdjldmBLmG +schZzDwTJzFTsctHFMtfftgMttpM +GHHWqWFWfWHqbRWsFZFmqZbhNjNDNppNjrjDcQdbpddhjr +wCLCVPfwgVSnPNrQhnDcjcNpDD +TPgLlggJLVwPVVPPwgTwvtSCFmzGGqzGZsGRqWBGfFRFJFRB +LfFLmGTPHBfpHmzBLdZfBfZTbWWttWSDJtWVDJDtSWJzVCCV +RssRRRhrRwQqMQQwnPngQrwvVSjttjJSjSVtWWCWjbVb +hQPnnRnQgNcQqqQQcsZTNTLpdZZfpZFHNpBp +VTCVVnwfFTvFmTCvWwJHdlhHWBJhJBRWNHgh +ZbSMZbctGtScQSZsSpZpPpplhBhtdJDRDJjhdtlRJRjNRj +rLsbBQSMBGspPGcMPQvnqmwzwmCVLmqVmwTF +GVrrQVHHHQGTllQjPHGrlCQpZZpJFWZFzzjBssDJghzhFZ +NSMmWmtqMWqSNbcctdLcdghpgpppssZgbgzpFzJJFs +cfLqLwMRdtNLMlQrvflWTQPffQ +FjtGflGsbNqjsmjGGGbmqQQQBQBTjdpTpJTWvJBddj +CPrVRMnvvLSRHLnBpwdWTRBQwQzBzR +SnZMZPcHMlqchsvGGb +nnJnswzPCtmZDCpmhphD +rSVVLQQQGQjwpdmdNmpS +VvBcQvGcQgGLBgWrwznfJsncltJsJnssPM +dhbwLStzSGmmmzJJvFgJNvnrgvhv +VTsTsRscRsVBMRVTTsjZVPCnDNvfrPfDvNCfBrPNDJ +scHHQTpJZjHwzLSHHtqHSt +MHmFsBDmGpGTBfmCfWCffhzgvf +wcjwnRLPZRVbtCjtNttGCh +ZLGVJRrnPPPwQwPppqDHFpBFTpqFDr +GzMgVfGRdRVngDjhqcjctrtrzzzs +QbQSHwHSLbWwJJFwJPLPSWTQjrhqtjflThccsclCcscCCmmj +JFbNSbLvHHLQFLvwQJFWSBVgMNGdBBnBMVfddpGngB +sZHNJwMsvHswwvMWqBzhChWPMBzd +bHQQQRDHRcRcDljttBldlPBdggBCqB +QjnDbDjjjncRjbQnfZpvssZNHnppFNpvvp +NdmfPNMHMdNMHcffHBCwwsvsRRllvwlcqjwscw +VLhVGLpLShgvrjwFhjqfls +pppnnQtVpGZVWtzGgVzgSSfnCCDmdPBMDbmmDMmdNMBmWNmm +rrfgCrrMllfnBhBrdCFfWLFmmVFVWQvWwtwV +TmSGSqNzvwwTFVvj +NSGSmNbDzpmSpbHmSJqqlMgdMndcgdccdpgllRRh +bbPtLnLcLJzTjcJbbTcttLcSgwmvWfVvfVvBgfmWVJMJMJMW +ZsDNNGDRsrHzpNRwMlgRlgmMWvffWM +FGzQpZGGLFjnSFbF +DQZVDdWWNBtgWnJCnL +SSHSmbHRFqGrmqJrbbGzjmzCwrvgvwnBwnCvprwvpwwPvv +qFFFSmsRRzzFjcFsSsjmzJzflhlZTTThdhVflZlVDDhMcN +cdvrFddqDtDvqgCDtFtrvvvFSmShPShJVJmMJSJbVBgTlmbM +GzjpHzGHHfQNfJSlPQbJBSTJBM +HWpspsWjNsGRHfpwNszzLfGqnCnZtdvvcZvwqFCcZqMZCv +rhHhDhhDrRNwDRhNRLRqNPHjHSpVpVlljSSMnlHnjS +sVVBsFBJBtBSPSjtjPPZZS +JmddVTzsffcGNwzCqNqR +nQfqFtZWFZnFJWfpGqhDsGLLPLVbrPhr +CzjwMTgBgTNSGLVVDPbjbS +wMCmgNNdgvzGdRQcFGFdfJ +CbqCDnwFpDpCVfBPmPffPfRfpB +svcsjlGJGnlnvjvzgQQgGzsZPhBRcRPhWfBZBhPhWRRhPN +sJngnjSGGTGzgJGrrbCqLHrCLwSFqV +hnRnJrwMHnQRRRwMhRrnJRBLZtBPdPSdtZZjjstsLHBP +pBBzzcbTbzCcFzTvlSCZLCtSvvttdZ +FWmNzBFNDnRqNRDM +lvzlSPRDSpDJmNwNGgFpfsFN +WBHrtrLBbhWHtdrFwFFsjzwfFjsdsF +HWnrHnTWhWTCTzTBnRZqDDDCqZcclRvSJR +qcdVbpcMFQcdMGcMFjjpbCnCGmCnJHDHDGJChzCJCJ +wWwlSfBRgRNBDPJnCgCrgzms +tBTfTRwlwRLNwTRmWtNwQFZtqcjcdcqpbdQMqMdd +jJRzwDdwFdJddcjjFCFvQLvNlBhSBhCC +gMMpbHpmnHpWfnlCSBQCPmPllQSs +nHWHVfTGdTSjZzDT +sCVTsBPltgDSbLvRMMDT +WNrjNmWZwmZwfVLvLRbRNvMp +mrHGrmnjqVzjGqdmCltlhFFllgsHBPCg +wbglgTFRblnMRltJBNrDDWQbtdbN +dqCpcjPLGfHZQBJNGGvQDZ +SPssjVSqPCLpScfCgFRVmTlRwndlRwTR +hWMWMhTTDgWMzGMszQShGWJPCQmPVCNPffPfVJftqNQC +nbnHHwLrnswwPVCPZV +nsRvFHLsvplvrcsSWDDDddjjDlMTjT +HRCnhWZhCddgwRcwhdWZHHQLJzSLsSzjJwSjztsmtzsmLF +VlVVNNVqTlMVbTVVMqvqvrDTjQfFtjstJmzftfzsSbtStJQb +pQvvPpBqNBccPWWhcWWc +glJTndVWCTDDVFvnVndVlCvwmBmqBBwQmwPwmMPggGsPGm +NhcSrhNZHhZzRtHcNRrSMSMSFBMGmsQQGLMPPF +hcpRzbcHjRhRbZRzZRztzRpJVdCdnfCnlFvdDTnJCVDjWd +dqWvjjBdWWqMjdvvMJjWWjMGgcfchhzrhwbrwShwgzSqNb +mmmmsVTlVlsLQmnpsNcfgfwNLgczhcGhzw +RslpsnGGGlWdCZFMMRWR +pfSpZSrdSMVDVVLMMDDZpdgRWMPGqqPGqmqqGGhGHNRN +wwQBwtjvvJlvsnbTbvBRHgPmlqhlqWWHqZZgNm +JnQwJvjTtzTZwJnbzzfCrfLCfdfdddfD +PZcnljZFTVmQdlQh +JCLLqBBCSNCCqzJNzStBpStBmsdhVTdmVWsWmdhfLhWVdfrR +BpMzzqSzppMMqpJqqgzPFcjZjnTjgcjbPjPDPZ +HLHWmqBHHqWbMHFtbgWcdhspPcPchndPpn +ZRVSQZRfVZGRgnfsdhLgLndL +jzJRwJRSJJvSlZQGRVwlSGZDMqmmCCCmtNbCmtCMzFNLbF +fDhlBhhZmQRRfHwLdjHFFWQQjQ +ZMTssVVzvbCqJddsLwwH +TzgTbgGGzztMbbvzvVbGvSPBrlShRrfnNrnBDlNcRDZRZB +bjfqGfvFfcHvRwGFRHjbgQtddlQljWpWnQgdWWll +TSPVVSVwSzSDTDlntDndnlWddt +hTrrNCBCVrCrrVshThHHbZvFGscwbfFGRJcZ +jNhMjcgvMNgWggvttcFtchvPFFzdPPrQrrGGQQszRPQrRG +wSCqCmmppbTwPnGHrQdrGCCD +LlqwGmGScLcVthVt +dGGrWWDqmCnwCCQMQrMbFHbMHsPFgPVZbgFPgg +tLRTBwfvTBJcZFNFZRHSHPVN +zjJLTvjcwDzqqhGD +DzrWszFFrtBBhnhNCClHlnHbSbmlSn +ZLwLcVVZcLVpvRwLgMLpLJgPmmQSNSTNbtTvQmCHQCClCHCt +cfgZJwwVLJZPPVpRwzhzrrfGGBrGtDrBsf +BTsdCQsQnwwdcCqqdCnsFvGFpFBvGzrLLmmzpvfG +pjZjgPVlJVMVtgJSWLPvfFFFbNNmNbvbmL +ggVplgJtHSSggdCHsscChhdnnR +JddZcSlvvGFJNWVWFgQgVtFWhg +nDqsHqCszwjCCPMnfhfBhtdWggfg +bqppHqqHHbPLjLCppbwDdRNvdmcTmlNZGGbTTcNv +lcZDSvztcHHcMSZVHVvMZBqBNNFNhBNTTmssBqBcFB +bbGJQdQPpGfQJQdJfLFhmznhzLLNTFhNhf +JGpWpPJddbPpPwpjbtZSzltDgWDSgvtrVv +lJcNlNjPcmtFzHtHBJFg +VPZdwGGWVrsdPWhWwhzzCzzFppDFMBtttFCr +wshsLVfWTnGswdhwcmRjRmScqTcjlPNq +BsBshRZQQsVdsZQZSdsPDwJDHNNHBztNNFMGGwMF +nSTpLjcvHppzwwNt +jcqncjjvfmgrCfvqrnZbmdmSsdbVWlsmhRdW +FjjqRZjZFZWFqPvNvvPQpmbPDCmt +GSnHSnrScncHhrtncGshVbmTmbpVvppCmpCTmTCmCC +rHfnddwdfctlzFFgwqlj +wBwlBmmhwRVThVBmFHnvHMnfsmFfHq +jzwGSGJNZCCssHfsCPfv +GJbzbZdbwJdtdQphRVWQ +ztFZccVHFWHHLSDBpSBPhhZw +fmjsCmqnNTJnvbTvLRPDlCpBSPBpRShl +JqsGTSNJGqvqvNvttGQQGdFrQctrrF +mNZqjTFrZqrTNTTGSSSbrhrhRFRHcnLCzcCdHcLBdccHLzRC +JDDfJswJDWsvgVgwpWnRBlBzGCnlCLBlcCDl +vVGpfQWJpsPQMVgvppVwgWPJrqSZTrZqhTQTrhjbjqSSjZqt +fMSDzDHzpDDVsStdDgwwFZFrrMPCNngCZP +WmLnbWmvvWTTLWWQWRGQvLvrPFZJcgJFCZNrCgGCFCPNPF +QLhlqhljWvRQbbqlqnfStnHdBqVVfzpq +qWZtSQTSvJJvBfJVBBVFNDNHbbdRVPdpNFRF +fGcwwmCgsLhgwLchbpHdrrrphdPRPh +gMjllmcjwsLMgcwlMnSWzSqjSZJqZqZfjQWv +cdRHPjRFRdFVHGcFfFTHQTHVLSQBsbsqSCLqllBJqqbSqLJC +WwWppWgtNrnzzWDmrrmNvWJClJSSbqLJJCGbsCgJbLLg +MnvWpmwvWnvtGPjVRcHRRHMj +dLMDhdHGrcLTvvvstB +nPqgGGNPqRgRSjgmlWjbbTTPPBvpvpTcswwsTF +NRGmgjRnWgnZJqllmSqjnqSDhQzVrdQHDfDrDJQDMHDJzM +RgmcPmGNQwwNmSRwPPgfmrBlCDlGbvFFvtrCsvlrBB +nfdVnjHdMWnTqflFtbjrllrlsCDl +TZJVMhnfMnVMHnpRRNRzgJRzSzgwPR +nTbsblzlnGllmsNnbDwbcWQWwWBFJBQcWQvPWFJM +HRZRdSRdCdLdRftrHHZfSQBMWJMgMzQPFWMJCFWgvQ +HVzrLrrjRjLGnlTnlDlsjj +RQdTdZhWqlZhTdWTqblhNmTMVnnrQsnnpvgMVMHMgHMrgP +fjSSfjcCzGNBjCjsnpMVpnpzvpzsHp +GGwLGSccwjwLwBcGLGSqZWmmdLZLWThmRNZmWR +ncmBrmfdfcVcfGnQdVWRBRvgqNvDvWqzLRqg +PlpPbSbLFPLpFstsbqRqZMqWZqMWSDRzvq +sjtjHCwJwlHfdfjccmmLLQ +tGMtLHQGWzLHFVQtVfQtMWtbgrZNbdfSbccggrcTjTrfbm +swRChnwqhBCCCmSjcNSdcd +vnlnqDRlsRnJJqswJvGMFVMMdWtpVJFMQQFL +ffcHLzGmfvqqfWfF +rJrrRSPCPMCrPRQMNNWJQjJCnqFVVVTStqVnSBdqppBVtpqd +jNQQPjQMCRQwwQbRQbjMgwbNhwWZHHmzmlchlHHHDcLmWzhD +JzvrRHHJvCRZFPFnPgsQVVQNzQTQDttVsB +GSMjpqdbGNppBtDhPN +MbmqMwGbZPmPHJmv +ggVSVWzCNbbNCbRM +DfVhVsVQcQDmpmQTTQLjPjMjbDGNlbRMlNGG +sftTFJJccnphcfncTsfBvwZvrzgzZzZvBrVnzq +qqlClBNSCNSRQMvdrwFvnBrr +GDfhDtszhhsThpTDzsfpprMrFvQvrnnfvQrwHFbfFH +VtggWhpsmGVTGJWMjWjNjPWjLL +NSnShnjsswSsRPNsrnwcwMHfFwGqbvqCbFfg +LDJtzzmgVVlvqGbzvFfzff +mlJmQQpmJpZpBJJdjBNhrnnRdTTgNN +RtRRvbhDFPHHlhtPhRvPRtqjmzqzzwLjHQHLLLQVmVjq +WNNBBZfgfWnqVQwNqzmQcm +MZGfzSrTTnWrrWsTWnfSGbGllPCbGlJRvlPllCtt +phgcNfqgfpZsjjpdsS +brHHnWPbDPDbTPlDJJvJJPrMVVzRSdFzwdZZzFnsdzzVdVZs +SbStvJMDQgNmmtgg +lzDMDhfFRlfMFTfMGPMbFTlMpBHrmpjjCFjmBmrqBjtCmjjq +VvVswLLHZnJJwdndNsSSNBpCpjqjmNgrmCNtmmqm +nHcZWcSVsScTDlPPlTPb +DFMQSlMDpSpFDtDFccHvmqzvbHZjJmvzmmQH +CSgffrPssdgqRbqzzRqZ +dsdsfGsrBPsTVcMctMVNNhtStW +MDWRDWpgDvWpNptvNMnJCHJHMwHCndJfZn +blcrqTFmmcbhLTTTmlBZbjBJdBfBnCbQBdfn +TzlnhcnzTmhLRvSDsRzDPzWR +nwmmPnnPDjclhhjfFzzzwqbFFNHwVqVq +vSQrbpWCvMWQQWQMLgFJVHqzBzJVNqzBFL +CvCvQtWWQmcbtntPcb +qzvtzCCtLsLLzmQCHqpSsHSmfrnNrTrNWWMNGnWZTMZGBvWn +PglVFJwPhbcghVTBpBnWWhWnTMhB +FgjcJccVpwDcwFgVDsqzddqLqSDSCQQL +PLHsSVGGPvSLTffjMJWJJBjfBL +gNhwgTqDcqwpDqNhFpDFhFWfnndjcMJjMWzzBtntJBnW +DFhhQRRwbCbwRQChppmTHCVGTlslrsvrrSVZ +hHnRfSMmsSVrFvQqrmDPgr +jjcBzjZLpWccJLczBjZjWGwCnNzDvrgPCgQvFggvqrQFnr +jtZGpLwjWBpBWcfMTttfbHRnHTbT +swSHffFTVrJlHFSWrTpMZMPhMNBqBhTvhhqZ +bQbLQGGjQLdRCcQjGZBzpzBZqMBBBVdBqh +RjQDQGmgmVVbVcjjmjgcnWtJfrwsfrtHlwswnfHSFw +bVHbbMFDcbDbcmbbHVRbMRFgzSmdzSSTBtTjBdQTzlSldQjT +nqpqCMwJffqQSzTBQlqd +wvJhnnfrfsJrCNffvspRrPPFMbPMRRPPMZgZHR +FnJZnssHvMdJWJpW +mlDlllGrSGmttwlGvZgrzZNWgggzTzdT +bCltZCthtRcbcFbjFL +JGmHrJwGzzpllRZdzZLRcW +htbPSbVtFbbgjhffgPSfTVSDcHDDDLWscRdsZjdZcRssWc +vhfFbFvVHbtTVgFPhmJBCvBNrqBBrGCqQB +BcNQcvcBchSQNccLLvhTqbJZTrHrrrzzqTZMZMFZ +tpHDsnDRslllCCHtwnpsfjRgrJrVMfMmMrFrzVJFzrVZbZrr +tnDpjCwPLNSPdhPH +qnjvvBwBhSSFPgDQLVVDqgLr +WbszTbHTbsbHJWHLLMVZmJPQDrvmZL +ctlRbtCWWtvlSfjljjhBnBNB +TsnvssDDQlRbzMzjDMqHwq +tSGjZCfFZtCFLtVGWGZFbcqwHbhWdbzbwHbdwbdw +ZGBFJFZVBLjStZPBBZLRvlmsPTvsgrrnrTllvs +PgQdNsQFsdNwWqQBsQrTrTLpbrnTpGngnbTG +hCzzMJVDmfzmBDMCfSfhTMGcnpnTcjGrpjbMGjbL +CVVfvCflSHNHvPdBHW +DwlMjMNjStgmthMghg +PTlpHnJJTcZvTTbHZWZTvpqdHhmLgrgdfrhLLsmshmsLts +vncqTbPqcpCnbCPvccZbDBCGzzNBwjDlVVGFjjVR +QsdGGCztZVRddPgndf +DrNNBbwNHNwlbjFbbCNjNwDWWDPPVfDMgfmVMfnMWmmP +rvJBbbBNcLCtJZQL +NfLlqLhbNPddLPqLhpgHwFFwFHHTwRHWwPFTrT +MSMSCnjBnBjCscjVDVljTvHmmWnrwTrwFTrvTWTT +JCMMBzDMJcZZCjDzSBDNJgdfdQlqlLNdhgGLhp diff --git a/src/main.rs b/src/main.rs index e7a11a9..59c4969 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,3 +1,93 @@ +pub mod priority; +use priority::*; +use std::collections::HashMap; + +// part one +fn get_sum_priorities_errors(rucksacks: Vec) -> u32 { + // get a rucksack + // split the items into two compartments + // note: there is only one error per rucksack + // go through the items in first compartment, put in a map + // go through the second compartment, check if the item is in the map + // if this item is in the map, then we have found the error + // find the priority of the item + + let mut total_priority_errors = 0; + for rucksack in rucksacks.into_iter() { + let length = rucksack.len(); + if length % 2 == 1 { + panic!("rucksacks must be even"); + } + + // [1, 2, 3, 4] + // 0 -> 2 + // 2 -> 4 + let first_compartment = rucksack[0..(length / 2)].to_string(); + let second_compartment = rucksack[(length / 2)..length].to_string(); + + let mut first_compartment_map: HashMap = HashMap::new(); + for item in first_compartment.chars() { + // convert char to &str + let char = item.to_string(); + let item = Item::from_str(&char); + first_compartment_map.insert(item, true); + } + + for item in second_compartment.chars() { + // convert char to &str + let char = item.to_string(); + let item = Item::from_str(&char); + if first_compartment_map.contains_key(&item) { + // we have found the error + let priority = item.get_priority(); + total_priority_errors += priority; + break; + } + } + } + + total_priority_errors +} + +fn read_input_file(file_name: &str) -> Vec { + use std::fs::File; + use std::io::Read; + + let mut file = File::open(file_name).expect("file not found"); + let mut contents = String::new(); + file.read_to_string(&mut contents) + .expect("something went wrong reading the file"); + + let mut rucksacks: Vec = Vec::new(); + for line in contents.lines() { + rucksacks.push(line.to_string()); + } + rucksacks +} + fn main() { println!("Hello, world!"); + + let input = read_input_file("input.txt"); + + let total_priority_errors = get_sum_priorities_errors(input); + println!("total priority errors: {}", total_priority_errors); +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_base_case() { + let input: Vec = vec![ + "vJrwpWtwJgWrhcsFMMfFFhFp".to_string(), + "jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL".to_string(), + "PmmdzqPrVvPwwTWBwg".to_string(), + "wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn".to_string(), + "ttgJtRGJQctTZtZT".to_string(), + "CrZsJsPPZsGzwwsLwLmpwMDw".to_string(), + ]; + assert_eq!(get_sum_priorities_errors(input), 157); + } } diff --git a/src/priority.rs b/src/priority.rs new file mode 100644 index 0000000..512c053 --- /dev/null +++ b/src/priority.rs @@ -0,0 +1,176 @@ + +#[derive(Debug, PartialEq, Clone, Copy, Eq, Hash, PartialOrd, Ord)] +pub enum Item { + a, + b, + c, + d, + e, + f, + g, + h, + i, + j, + k, + l, + m, + n, + o, + p, + q, + r, + s, + t, + u, + v, + w, + x, + y, + z, + A, + B, + C, + D, + E, + F, + G, + H, + I, + J, + K, + L, + M, + N, + O, + P, + Q, + R, + S, + T, + U, + V, + W, + X, + Y, + Z, +} + +impl Item { + // match each item and get the priority + // a -> z (1 -> 26) + // A -> Z (27 -> 52) + pub fn get_priority(&self) -> u32 { + match self { + Item::a => 1, + Item::b => 2, + Item::c => 3, + Item::d => 4, + Item::e => 5, + Item::f => 6, + Item::g => 7, + Item::h => 8, + Item::i => 9, + Item::j => 10, + Item::k => 11, + Item::l => 12, + Item::m => 13, + Item::n => 14, + Item::o => 15, + Item::p => 16, + Item::q => 17, + Item::r => 18, + Item::s => 19, + Item::t => 20, + Item::u => 21, + Item::v => 22, + Item::w => 23, + Item::x => 24, + Item::y => 25, + Item::z => 26, + Item::A => 27, + Item::B => 28, + Item::C => 29, + Item::D => 30, + Item::E => 31, + Item::F => 32, + Item::G => 33, + Item::H => 34, + Item::I => 35, + Item::J => 36, + Item::K => 37, + Item::L => 38, + Item::M => 39, + Item::N => 40, + Item::O => 41, + Item::P => 42, + Item::Q => 43, + Item::R => 44, + Item::S => 45, + Item::T => 46, + Item::U => 47, + Item::V => 48, + Item::W => 49, + Item::X => 50, + Item::Y => 51, + Item::Z => 52, + } + } + + pub fn from_str(val: &str) -> Self { + match val { + "a" => Item::a, + "b" => Item::b, + "c" => Item::c, + "d" => Item::d, + "e" => Item::e, + "f" => Item::f, + "g" => Item::g, + "h" => Item::h, + "i" => Item::i, + "j" => Item::j, + "k" => Item::k, + "l" => Item::l, + "m" => Item::m, + "n" => Item::n, + "o" => Item::o, + "p" => Item::p, + "q" => Item::q, + "r" => Item::r, + "s" => Item::s, + "t" => Item::t, + "u" => Item::u, + "v" => Item::v, + "w" => Item::w, + "x" => Item::x, + "y" => Item::y, + "z" => Item::z, + "A" => Item::A, + "B" => Item::B, + "C" => Item::C, + "D" => Item::D, + "E" => Item::E, + "F" => Item::F, + "G" => Item::G, + "H" => Item::H, + "I" => Item::I, + "J" => Item::J, + "K" => Item::K, + "L" => Item::L, + "M" => Item::M, + "N" => Item::N, + "O" => Item::O, + "P" => Item::P, + "Q" => Item::Q, + "R" => Item::R, + "S" => Item::S, + "T" => Item::T, + "U" => Item::U, + "V" => Item::V, + "W" => Item::W, + "X" => Item::X, + "Y" => Item::Y, + "Z" => Item::Z, + _ => panic!("Invalid item"), + } + } +}