day 3 solution

2022/day3.txt

@@ -0,0 +1,300 @@
+dWlhclDHdFvDCCDfFq
+mGdZBZBwRGjZMFgvTvgtvv
+jwwJrzdzGdSbGGnNlzWczHzPHPhn
+cczcbMBszhzzDBTBPPPGjtvtlt
+LqJLfpwdLnvQLRGQjGtj
+gSgnSJJCGSGpGSrwgfhchmmmHzcrHDmbrmMm
+bVjstCsSstCLCrbSLnMpdMndcLddcqcpHR
+wPZJQJwtBfJZmgBwPTcpTdcnfHMppcGMdG
+gmFJzwPJJtszvNhCNC
+DmjZDMZWDqGRqqRpHmmRLTTNTPTfCQJQQLJHTClc
+FtzfvrfFwVgtzztgBLJNcNlTcTVNNQLN
+vgsdbzzrwtqWfWRpZDdZ
+rJhqRhLHhdcQqdHqfQGfPGstgGPlWttM
+DzCpDDmnNCmBZBZnVBmZzBGPfsbglfNPwgPGPMWsWWft
+BZFnlmpBpBzDzVZmhFHFrrrchhRqTdrc
+DWCCWFNqdGFdPVcb
+HllttQsTRlJlsblrHlhdmPLVcVcTccndLvPLmL
+HSlstHgJltghhRrzNBNDzSwMjNZwNb
+dzGSHCWSsGVVSdHVHHWWVVDCgJDpQqLTTRJpgmTLRmJTTpTR
+BvNjMPZMBtBBMvvNMNttlhLQqCJpLmhTRQqQJgRJLQQg
+llNncBlMCwwMnwPZrGsVHzcfFGdHGFGs
+JfZhphMMQmFzDTDjSdrQjQ
+sqHCbCwBVtbqbCqtrWdjzlSJTlrTSWBn
+bHcwbGCGRssNscwtHNbwvmRFvpFFJFvLZMmPLFfv
+qBCrzznVmDCmMMDNgrgcrvHHcgbQcW
+TTTsdJRTRhhlsgbvbdCFdbWvbQ
+JhGGlfRlJsnCMDMqjmfV
+rqLLvDLtStDLQhQDQrQhhNdsmWdmmjjnssPnTMnTzfTsWT
+ZRFFpgCgppcBcnjTsjTMTfPFMP
+GCZpGlwJwBgGHcJhSSHLDDrNqrMtNq
+FsPFqsDNZFNnZrcBmWfWWQ
+lSnRlRTvgrWtctTmft
+SMbGbbvnGlnSDwGqLwNCqNVD
+dPQDcBwJJDgDTPgGgQTBVjSsmLhLTrLmjSLpjSLh
+MvvZRHtMtbCNvCNCNtNvbRfBSMSrjmLpjnjmVhrVSLsnnmSh
+qHZtbBZfRztbHbCzNRHPQgJPJgGgglFPPFqdQD
+MsBsVDspRPfPlhMl
+zWnCFzHbSCwqNmPSjmGlsmfN
+FnHnFbFzsHHCCgzCzbBptVppgvvVgVrpBrJt
+pTLntptZjQLfVDjQTDlVJCSWNCPSCCsSNmFlNslm
+BBHbqGHHqgwSWSCCWwZWWZ
+qRzbhhbzzrHdRRHhRHvzZjfrVTrppVQttDfcQTfp
+DHsdHPHHsHMsRmhMZZQBtljgZGtC
+NFnCbFznLVJbVrjhQthjGBLZBjGL
+wNrfFJJbCpNnfbdwDSDHsvsHmsmH
+jLZRjnMMjJhJnvtQbdHfHZbvHQ
+mBzwptCWlcFCwsHSTpQfQHQfrpTb
+mNltzmsCNmFzGwCBllGRgRgqjgLMnGqjnPjV
+ZqqcqmVVtbcBMFfFMcQfgphJ
+HLWLDvWjjLwTWzzvGLThQQshQllgJDJgfbffJQ
+vHzLvrwwzGzTRGzzLLRPRwRdSVdnBBdSbBSVStbNmnrmZS
+TWVVvPSgwWSqcRgRwbRRcqshsfFzzzChTGNHzHhhhCsG
+njZrjMLlpmDmGfSGtrNttzCF
+ZQBmZdDBZRRPRSBgcb
+TpntvdpnZDptnbnTDGtSFSlFmzCzzmSFRjqlZj
+MWrNcWRMlgqzMjzq
+NPwsPNrBNcVHNNcJHBNBcJwwttDvGVnDptVRtbnTtGvVGtGG
+tsbbvvSfnqvzQLLBjfMLdd
+gJRmRNmJNchgmmrFJhFgWJQMwBnjwrMBVQwQTBdLdVQj
+GcGpGGRGJgqstvpbnCqb
+rsHcrbZHBTTtLtNSwwHLLJ
+mFqhWVsjsVCjQlNJGMwMlMMGMh
+QggzffQRCfgVFWzzCQffqfZpZDcRvTTBTvvZnsdnddcn
+bPFMFFBpMlFfMZMpHGNSrNctJcPSSchJchPt
+zCgwnmgzQDnQgdWWQRgqSrqLSqSgssLNJhgJ
+rQCQQTrRRmDBFfbHBFHZbT
+fzfPQsGrrMMjtHtBHs
+SwNNDqwhWpVTwbDGGDmwSVhZRZHdbCtgBjCRjMtbBHtRMd
+vVTGvVGNvPPvQvfncJ
+cwzMJbclHDPqfJQPfq
+rrqjjTBrqqBjRCgTjrRjNrsGPDhDFGCfWGfPFfFPGWfD
+BZTTSTZgjbSwVptvpq
+PPPPJpvpJsJwPHHPsJdTNZRZZZjTFFmRRRNjZd
+qbWVfChDCDnVVDGfnSFNNjRLmNfBNLQjLjmBRm
+DhFDhbnWCDhGcbJPPwrsrMwrvlvc
+lFSDTwHTSwlTNwFFlwNcFFpjLZvZqvnqLPnnWbgngbbncqbZ
+rzQfMzRGrRGJCffBMGdGsJZWWnqWVqdPPgNvvVZWPWWn
+RJrttBtNQCsNzTpShhHFDwFlth
+QNzQFjNFrQPNbmPpqTTDGswWmB
+ggHRcSlcCVCSzMVqDGwgqTWpsmqwqG
+cltzCZtLClHRRtMZZLQjfNvtrJfhvrddvNNd
+mcfWHffBFnQRQlTFdv
+wssSLVbbzDVbzbggzSzNshNMnvnljRdvQRlMBjvQdnCj
+bhDzVSSJDDJhDLBwtbDzzbbWppfpcmWGmprqqGtqprcHPp
+rpVFrZpgHWSZrFPqhzwcqPwmcVBD
+vMTnQJjQLCbljvvQzTMbTjPNdBLwwDhmhNNqPwmmhhBh
+jvGjjQJnrspGHgFz
+sjssjtZlcphZHwWvcrHTwWJH
+qDdzzrFNNNDGdFDzzVBVVvfWJPfgPmgWPgvwVH
+nqMQGDrnLGnqqLNqjtCZZjsMhZhCMbtl
+JJJsLFmzsrFlSpzPscjgHhnRnmvcjqRvvj
+fCMQbCbTjjqTGhjc
+bfdbWdCddfBbtCfbfbqVWQQpPlBrJLJJSSLwppFssFzLzp
+pdbbzlffWtJbgQwhcphQcCCg
+vHvLFvVLvSfFRLnRFRNHjPjggcssQcjjsnwhsPCC
+vGVGGFFVHLTvDRHDmBbTzfZWMdJZlfMm
+wjCbjQgjTQhNNzgWQCWrDFMZmZDZDCrrMDpLpL
+czGSPznnRGGJGGlVVRVBGGlBmDDcMDFDDZLqfffZFrrZqFpZ
+JPGlvBSJHVGnVsjvQjjzwdwjzd
+MFlWQHDTpnpsFNNQllWFWlhzjGgrgDzGGhGGjvmZDZrh
+PtTPcTLbBCVPTRVcvhjmmhVhSZGGgvZg
+JLPfCwPbTbBPJCfblplMpqWsMpMwWHQn
+QbHVBBzWtzHBNtBwQSgqhqSbFgRLjhmqqj
+ZnCnMcdsDnJTncggFJwRmSwgRFmL
+sTMZpGDvsZcMpcvTCPHwzrfzrpzHpWBrWz
+PMdJWwJWHFWJnNzbDlfbCfMvbl
+rZgttrFptFFcBtccbbCDvgfbGCGGgGDz
+QsZBmsrFscrVrjQJjJQRJWWLwq
+GwNNJwwRThwrWfhh
+SmQqmzsjHssQzCbvsmSSzsQTjWpFTTfFfThchhFTBBfppB
+mmbHbmtmCzzQZzQRdZJhNMdMlRMglh
+rrsPbncQvvgnnrTdGDVcCdpZHHZp
+RwwwhjLLqtJFwjzwtwmwwGpDZVdGDVdZBZDFHdHZCp
+zhzwLhhfffLtjNChgWbbrbnMvPrMrrfv
+tQMtQtTSBFtSmQSttMggMtbtnTnPrZvrnzNNTGZvrZZdLdnL
+HqhwDpDcwlHqpVrrFzvFGpZrrzrP
+RwlhhjwRCjVfjDbMtFWBWJMgWjWm
+WpWVlWzsGlBJpspNclNlhhhmgzrdtzQMQttzMmtt
+RfnPRLTPDHRdPbwvvntnSrFgmvnmtm
+CwqRDCCwqCwbCTqJcJBNcZqdVcBlpJ
+tpfnNBsGGNRppRCgfgRRCRQJGMPPWdwMJdWFFwjVzGPJ
+chLSchLTbLqvqcZLlvvLqbmldMzFFWdzVSFWFMzQVJwjQjdM
+rLqqcjDrcvhRsDfHDtNNnN
+DjZjvTTDqrtTZZSMcdRdmRJrcJNc
+HWgPGVhFPgnSVtnJcdMs
+FPLfBwCWGPfCwfLHCCDBZlbDpBjvqTtDzzDj
+FJNqNFgNFssqGGqBsTlMVcgVrCwLwlhcrw
+fRZzDmDZvvDdZbtdpDZmbrThrLMCvcChwwlSTrvMSr
+zmfZmtZmpDmbfWRDDZdqFljqnNQjGWnsjFqGsG
+rMdMWddmJmvdSdmWfWMddpVRqRFVHRRqMRRPQMRqRq
+tDGtGGhLjLLZNLjjNgNthGtqHTVqRVVpPDRpHHVRQVRPPR
+ZlLtzNjgsZZlssLgtjNpfWfJvlJrrvCJfBmBfn
+hqpWvFJsJFNHhqMWNhWvWRmmDcDMLcwZnjcwnjRnjn
+LdrlgCCrSSTrTnwRjmwRQZwdwG
+PVlfClrLlLlfggtBPzHHhHFbWzJNbvqJFNqF
+TbbQtnDtbGGjGlGsGHpJJmFWFJJrBWWFlWrS
+CZzzNzzhddNchhMhhRVjpCBwBrCvJvpmSCvrwJ
+fhZZhddRjRgZzMZRzPjPTsLGQtHLTHTbDPQTtqPT
+nHnWsQNQQWTWQshwjBJJJmHwFBwm
+VZZpfbffZVvbSbGfBhSwmtmmJlmjJFJJ
+bpphpMfMvMzDbMGZgQNrrngzdTsNqWdd
+VPNddVTPPmdnVcPVZcdTmcDbQTFjMpjtFzbMtFjzsFTssT
+lJCllWCrgvRlgwlJfRRvSzjSjQpbzMHpbwMQpszM
+fRhGBBJJCgrNLsNPNVVhNq
+pLrVDgbNbjVplpsltHBqWSqhSQcHDttH
+MCdCwCGTmnTmmmvTTCwCqNhHQhRWcwHWBRHSqSQH
+TNTFFPfffTvFTJvTPCPTFfGdzVjspVLZglJbsbZpVblrzjlb
+cdPzFrldgcdCrnlznPzrBNRssLLBbVNVZsLHRHdm
+wTQQwvvtqwqcGvTZmVHBbVLLBbRV
+GWJSGfJWcjQwhQQWjqJhhGfgpMnMzDnpMlPpMnDlMrzl
+pMhqTTsSpdBPpNBshsdMMTQFvFlQtQWCRQlCllVFqVqG
+dfcbnmrnjzRFvGQQGvfv
+mDrjLLLcJjLhpZSSJMdpph
+NGZNwqFqZhhcFSCfRzwdzRfCzVRw
+QTTmBTsWQWJPPCvzvpHPzdvVFR
+bsmWTBbQDbmbLQQMsWWQchgqLqhGGGGZLhSFjhqS
+HgmGlgsvBBDgBGCdHHvHwCGwhZJWhTjSdhTSFFFhJtSJTJhT
+RQfVrfQNszMQfpMzpNnfLbtjhtSbWJWFWtFFtFJtFSZq
+PNzLfnLnBCPHgsgC
+mTZGgCdNSNmCQLLpPnDhRlGhpV
+vWJHWFsfHMWBBFbBsjfjHrFfLRRLPPnpLthttRVPLSnhSPbS
+fzMrBjWfBrzsZCZmSTgQzcNN
+mgmCZCMgmnZmZgBZpgpJfbQfwSQPDTdfdwSDfwhn
+sHhcrWLcFlzHcHRNNFvNFcFPwDDTWdddDdqWbSTWDPTTQS
+RNsslsRrNcRNvNRFFNvVsghZBJtVCCtCtGghjhGBGG
+gchrcRRdnRwPPnvQ
+CVCCSrDjFHjVDbBLFGGBSvwnwNMnMsPPNsNPvwPQVM
+lHLCTHGDCbbjFTTzdWlpcqfgcrdzZg
+fRDPsDsqqJttttJSzPDgJWQCbQQbGMWCCnGGPVGVQQ
+rTTBvZhrvBnWWDWCbZWW
+cwLlTLpjTwBFLLhgfRRfmRqRDmRdjq
+sprGGPTrJTsGPzszqGzNtTtpfbQddQSQSDFDFvvbZvwFbbfN
+LWWCMVmwMmgWFQfFDDvZDgdF
+mlMmRVCWVMmmHRjVCmjHWRhMzpTtlrlPzrtzwlsGPrpwtrJp
+tsfwwfjfdfrtrClfvwvvLnTHNmvLHcNccRNcvNWH
+qQSqZqFQRBzghDFncHgmccHNmWcNmM
+SQJphFJzRDSsdpVlllrCrw
+vGQqLQFvBvLvdNnvjnvNDc
+TRJwmWmZWlCCmzznbNhhbDhRgj
+CCTtDTlmDTWTmDmZZlVLLsFfstfFFLsBLQfF
+cfWflMmWWlWfPWBhBlQtLmmvrrrvCLjvRTjLLwwr
+gSgbsbgHdsjzHbqbdVDLZLvTZwLTvSrZrFvZLw
+sdbJqDNdjJNdsJBpBWpJlMcfcB
+FHlMHPqDLlPctgHSnttCSC
+zhrmBrTwJTjBmQcSQvQqbtwGvg
+jBjmBmJjjjRZTBzhhrBJLDdZqfpDMdfWWlDDLMlV
+zPVdbsBzZdwqJGhrLTvNNJqH
+tmmCgCPCDDnptHDjNvGvhrDvLv
+pRWRlpSpPllClnpbQVQwFFVSQFVBZz
+nDrCvmvMnMSmsCvblBzzCZplbJlTbZ
+FNRtFWRfcGqFGQbzlZTQqQTBbd
+GRwFfNtwFRNFGMvBsnnwMMMBjn
+LVTBjjlJCDrnJzJNQR
+GsGGsggGpfhgpchgdqzbMzzhzQRnnMRrNzzR
+PwWFqFGpwWpdWgfsGggdmjCVHPHlCCCVZNCjVmVj
+qVTsCWwbCsPlCVfcbvfPDgLzbzDDhrzRrjgZghgr
+ntmHmNpSQNGtntNttmSdSdBdjrrDLQZQLLhRrFFFRDTFZhDF
+mtMtBNTSNBpNJStMGSdHppNcVWPsWvqVcsVJfwwqlqWqlc
+vvWzLvvdpZDvhTpcrLcTTLpdwSPnCfJwCMnQSMwSnCGJrnwr
+ttHVmVNNsHBBRsHbMMwwnjnjBfjJwCMP
+tsVllgNVqbRlfplldDvDWT
+mLjLsQqLQqsBRvvlRBLRlT
+bhgtDDhCtmptmTTS
+nfmdbggwGWrfsPzfWq
+JpWDcSGJpGzsHPSSlbbd
+wVRqVZwwRwPDwbDddH
+VtVVVLthLVtVgfQLRTNtqDcCcJBmmWMWWprpFrcBJWNp
+dhhhDtmLdttdPlslGlRFjfzBBpzzRpGJ
+QMrVMwbVrrbvVVCrvcnqQQrrSMBJfpjFSzfjJFMFRWSpjjFG
+cwvbHHbCqVchRDHgDsPTdt
+CgVNCtDsDtJGZZGqMMGhDq
+cLRnSHgWcRdLHWSSRLjQdlHBTTPcPwwhzqzTMBPTwhPPwP
+HnnnglnWWgdRjlmQNsNFmJCFJFvsJsNN
+hfccLbjhfSRbfDZjFRJzrlvlwwlnnFrWwzqr
+TCsPLNtQdpdQQVtVNvJNJWlzJzwlrvJl
+pHtPsPtPtCQfbRHHDHhMLh
+nWRWgLtWnfTcZNNsscfd
+JMGzMVJwMVTvzVQFGHMMmPdddsPsCjldlHPcScNPsP
+vGrMQQmmvTQzMJpghWRWgpbbBqLbLR
+WSbhFbPTpRfTfPdhpfbhSbfPQLzlQlzlHvtQsvlltlsgHdgQ
+pZcGJDZNGcVrJwrDrrnvtNvlNzsgtgzvvsgt
+qmJZZJcBqwrMJcVbWfSPPWpmpjmSCF
+jHVjjCcpNrDgjsfB
+ndqllRvJQtqlQQTRWllFNDrsMZBfDBLvNMNDfsbZ
+qTFnWJqdWRdqWRlnTRnQGnTmwwSHCzpcGNmHNcPVcHGmCz
+pZCpBhDfvgBVZQGMMVZVlq
+sLsLTTSssjPnTNbFGRGFPVHqMMRF
+TsNSccnjLdcsLjdmjWvWvBhfmvWpCGhGhD
+VWFFFPMpPVSMbTppHTnHTbRH
+DtvfNdBNddDNSLjsvDTTHnzzHwrTrwsrwqbT
+dgBLNffdgjjtfBQSvgNjNDlvMcQJmJJmZCMmVVVZFPFcPMGG
+VWsQLHMVVSNRShWLhNSNLjbbbddbpDZDddcbZdDRztpd
+FPlhhgPvThGFJndnnCCnJzzdCp
+qrTfmllGvfvGqwNMMMsffsQsNh
+NsmFqNlmnQRbCFsmJgSffpPcbvSfrVvpgS
+LhZGDZhhwtDHMwDdHGhDjDpTzzPdzgTvcPvpSSpPrdrv
+jgHMjBLhwtZMHMHmJNNJNFlBqlBJNn
+bznSQggscgMcSTTfJbSQzQFwClMhmCmthClvMwFLwhZL
+BRWBPBVVPjPNVHpVqlqrvtwFqmmLqltZmL
+WDVddNHNvRgccgsDsgbT
+sNgnQLtLLLPPnsPpqdqjBclpGWjcWjBG
+rVCChSZhVrrwqVDVHSHmMjldGfJGfHddJGJlfGjGJj
+CVZmDvZCmmhFVVrCgTNbbnQFgbsqNqNQ
+WmMmSSfJNRRPfJRMRMtllCgdStgbgttgCdDd
+QGBrvzwBczlgqCtDbvDq
+QQpBGFrLQjQzGVVRNjPmNNWMbW
+gGljnJhnJtllpNVCHWcccdTdjdmB
+bLfSQDSMSHmBnwCB
+LFMDrbFfFQZQRzLZnbgtlsRGtltpgNhgPpPG
+cRThZZchCThtgTRhZTRtjWFjWNwqCjGmwFjqqffC
+DPDPGzPMHDbrpqjfwrjqmjmp
+JVHHDdVdVbvGMdnVdQVdDbHcRZllhRtgStRLThRSTcBTvc
+lQWPSBrrPZGgPglGssDfHnWsfDFHHvHh
+TDCqpttptJNLtwNpbwTqzqHshsvsMMFnmHMNfssmvmvf
+JCjqVpDtrBjQjrlj
+wFGWGpFLvCczNSWWsz
+tlfgtftjlbtHHlDBsBzmQQnsQDQsCn
+gjfrsVqVgPlfqhvLdvdwZhGq
+pHpZHBSvRvRCBBZCTMngRnWndnRmWcgg
+jsfrfrjJFDwDDMMggMCGWGcfmG
+qbCszCjtCjQsQrtZVBHBHvBvqLZvlp
+scFzsPScNgNPNgQzpttlCBCwpLrMLCrDdljLwq
+TjfGZZjVwMZwMLwr
+vnGbWTvTmFRjQFQPsb
+bVLrzqrzJVgJbbtVrWJVgppcBCzBvdzwBCCBHDcBvc
+hflPQnMQmQSRlQMPNRTHwwHHHqpHpdfwdBCp
+hFhZMhqSNMNbrZgWWGWJjZ
+NJsgNjJlMHQrwnRgSRPwrP
+tqpQtTFpFvbGpzTTWSrnSbrhwChCnRfrCf
+GtcvGqQpttzcqdFzWppDsZMJjBBsBJcBNmBjMsLJ
+lGfZGZhFfhdSWqmFFWSS
+wDRDPLcDnjtWbSmqrSCSLC
+MPwmtVnVMjztznHPgQhQfJfvvHHGggQZ
+llTspLllCHmLHHndldqHdlLQQPSBQczZSFDDQZSNGcGG
+jMhwvVrRjbRhFBZNGPcGNN
+wVtrrtRwrfrwftjVjwWvMrRpsqsnsHsBglslCmTsdWdHTd
+vPvmTGgDPRvGpDPGPqGHQnWJQJMBBzJBlBQWlHWl
+bfbwNsmwFdLjbfrrLsSfLNQtMllznBzJQZMQtMlZZnnF
+frssSscssNfScCjfSCwjsDmRDpGmDRDvvvVcvRDvRp
+LtlPZPjBTbWsWJVJVzdT
+nnprqhrqmzfrSrphqfCChVVGVDJWgSHHWgWsRDVHWd
+nrmppNqhcCrfMchcMCncqbzPZvlvlwbBNjPjtNjZjL
+FPWsFdSspVbbbtWVvl
+CCHnnfHHvCwtVMhzlzDllC
+LrGnjGfgfvcwfgrLrBjrBLgwdBTSRBFsRZdRsSqFFSFSSPPp
+whGCLqsrjgGhhGFqrCCFGCGzTRTZJcNnzlLTnznNHcnzTH
+ddvVmbfvdvVbDVQdvvdSzpNcnJzlzSRHNJpnJcSc
+BPdvfQdWtPDDPfDvDQVVPmbhssCGGMqgFCFMqGMWgMjrRw
+PSLbGmWPSPLQbMTPWGFWltthdDdrmBDHhdDdczzDRh
+VfCngVfgsZwCftrZdhcZrdNDzz
+CjVJJJqnJwQhWPPLQlGj
+ntnnQmTQTQGVWGNGNNlClG
+jDffjMSvqjHzHHzwNVwNVcCddPVNdD
+ZszJsrrZMjsHqqvZJLRQCbTRQbJmThbt
+BgLHgFDsJNWgQgflWd
+mnVVcCHnCGRcVnZSjmlthftMQddlfhQctNfW
+qbSGqmHSTFprvpvTTL
+dvdTMvvpdLpTcSLvdLLMmhfFBftwCNhRwRNjtCTRCf
+lshQWgsgrHHqlFfRqFjRFfFwCB
+rsgHQbJbrsGHHlgQHgJrlHrPZdhdpMZGDSDpdPLcZhdvhZ

2022/src/days/day3.rs

@@ -0,0 +1,60 @@
+use anyhow::Result;
+use std::fs;
+use std::collections::HashSet;
+
+fn get_priority(t: &char) -> u32 {
+    if t.is_ascii_uppercase() {
+        *t as u32 - 65 + 27
+    } else if t.is_ascii_lowercase() {
+        *t as u32 - 96
+    } else {
+        0
+    }
+}
+
+pub fn run() -> Result<()> {
+    let file_contents = fs::read_to_string("day3.txt")?;
+    let lines = file_contents.lines();
+    let mut rucksacks: Vec<u32> = Vec::with_capacity(1000);
+    let mut rucksacks2: Vec<u32> = Vec::with_capacity(1000);
+
+    for line in lines {
+        let len = line.len();
+        let mid = len / 2;
+        let left = line[0..mid].chars();
+        let right = line[mid..len].chars();
+        let leftmap: HashSet<char> = HashSet::from_iter(left);
+        let rightmap: HashSet<char> = HashSet::from_iter(right);
+        for dupe in leftmap.intersection(&rightmap) {
+            rucksacks.push(get_priority(dupe));
+            /*if dupe.is_ascii_uppercase() {
+                let val = *dupe as u32 - 65 + 27;
+                rucksacks.push(val);
+            } else if dupe.is_ascii_lowercase() {
+                let val = *dupe as u32 - 96;
+                rucksacks.push(val);
+            }*/
+        }
+    }
+    println!("part one priorities {}", rucksacks.into_iter().sum::<u32>());
+
+    let mut elves = file_contents.lines();
+    loop {
+        if let Some(elf1) = elves.next() {
+            let elf2 = elves.next().unwrap();
+            let elf3 = elves.next().unwrap();
+            let elf1map: HashSet<char> = HashSet::from_iter(elf1.chars());
+            let elf2map: HashSet<char> = HashSet::from_iter(elf2.chars());
+            let elf3map: HashSet<char> = HashSet::from_iter(elf3.chars());
+
+            for dupe in elf1map.iter().filter(|t| elf2map.contains(t) && elf3map.contains(t)) {
+                rucksacks2.push(get_priority(dupe));
+            }
+        } else {
+            break;
+        }
+    }
+    println!("part two priorities {}", rucksacks2.into_iter().sum::<u32>());
+
+    Ok(())
+}

2022/src/days/mod.rs

@@ -1,2 +1,3 @@
 pub mod day1;
 pub mod day2;
+pub mod day3;

2022/src/main.rs

@@ -14,7 +14,10 @@ fn run_day(number: i32) -> Result<()> {
         }
         2 => {
             days::day2::run()?;
-        }
+        },
+        3 => {
+            days::day3::run()?;
+        },
         _ => return Err(anyhow!("Invalid day provided")),
     }
     Ok(())

2022/tests/day3.txt

@@ -0,0 +1,6 @@
+vJrwpWtwJgWrhcsFMMfFFhFp
+jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL
+PmmdzqPrVvPwwTWBwg
+wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn
+ttgJtRGJQctTZtZT
+CrZsJsPPZsGzwwsLwLmpwMDw