fix tests

input/year2022/day03.txt

@@ -0,0 +1,300 @@
+GwrhJPDJCZFRcwfZWV
+LjnQlqNpjjmpmQlLlqNfZRvQcTWcTSTTZcSQcZ
+nNqjdspspngnmjmslqmjjjCDGrHPHMGddGCMCGPPPJWC
+GwmVZmPWWFFmBbVbZVwmbPsTCnlgQgnQfhlffffZnlQh
+DqVDSqqSMzLLDDNSHHLdqSdSllCQjsTlClhlflnTlhjgfgfM
+VHJztNLHGtcbvvPG
+bjrPrNCtNrjdcCPpptfpTVspDtfTtB
+JGQJMJQMmmmZMnnLpLBTpHCD
+WJJqWRgWlCJZhZRCQZwdPScdrPNbvzPzwvqz
+QNSQNBWQNLjZBNNhLhSNRsTcsrTTVzcwZZZsfrrbwb
+tCFtHpppppMldpvpqnMFmMVGrbPcrwbzswrzcccfvTfw
+pdmCpgqCdmHHdJVWgSRNJDRVVj
+sNrFnvNSzrjQtQjQTj
+lcPmcJDLdPDbJPVLljdGGBBThBQTGwTtBw
+PDLqmJmpJQfFqfqsCM
+BnhctqdnqnRcBnslCJJCMrJrsG
+wNDMZpbQwMpCvCGVjlss
+WfzNwZFbwZzZmFZbLzNwzzzzcdqgRMTTPdHPTTPMRdcWgRPt
+grsrVSFSSdFSDFVFjZZWwpWpZWZplgZZ
+mcBPPPBLBfNdLlvvWljWJC
+dMcmcRdbRzdVhFthSsTShM
+bzvJZMTzTZSHLCCdDzmDcc
+hqBqWPFssvshWvvssNqtsHftmfpHfdcdDGHmcpfctL
+WvBQgNNNhghTJbJQlJTZlT
+chcdwNwdbCbQctCjnnQGHsQspMHMjG
+nSSSJqJZzJgWWRfZDJSnqvTTsVvvHVPpHVfpjHMTjP
+BZRDRmmrDWSrZWWzWSRNhdnCFwChclFtwbNdtr
+lNgmssCtqLwqCCtfsCLHPFhhhmMhVzBDbVzMDMVz
+ZnRlQTlJzFQFQFVV
+npZJvRRGZSnWvSvrSLglsClfpfcLgNgpHf
+tVtqcVqFVtZhcfFtqlgSpmpDSDNPzSzZmNpw
+LRGTHqbrHdnGHrTCSSwNDzMDwPMzNwbp
+TqWGJrGHCHnTWnhsWcFthFjtfQch
+qNnTbwtctvffFcqfrHjMrFjVHRjSjZDZ
+dLLzWWPmCmCzGdsLgBLGGBDRMVMHRlrrrZDDZsNMrNNS
+PJQWggCzWNWJzGWfchvfTbJvfnnwtf
+ghzdgzzdQsdqzzhMNqQzvhgQnRRBWTjWWGTRGWwGTZhwGnBT
+fsrfJHbFfDFLVLVFHrWCWrBRZZTGCCjwWZ
+HLLllcDPbLPQdPspMNgvMt
+fNDJqdPNbtHpCbwpCCCp
+RTMRLrzGrMRMRPWnnvSmgCHFCCFmmT
+WQsWQjzGWMsGQzWclQtVBJfBftNdtqVPfP
+gbTCVVmDVFdsgmgrrcfwlwfTfPlcRR
+qhQZqQvnQhLQhJnvfPcSwSwlfjGcqjqj
+tLNZLZZJJZthpzhMZDCdFmFsmWWmtDDgsw
+bqCvLvLppzPzPPvPbFztFtttBNGdGsRggSgGSHDdggHSzNgH
+rMQpWfMfrcTjWJhwWHHsSBsRBdSTTNBgSR
+VwfmWjwMWwccrWcWpQQFnFtlCqmltFnFLbbZmn
+cWqsMWJMzqJJMHsJcqsJqTqjSbLBdfdSbtzLbbLfbSfShfhd
+gplGvQmRrCrgZSZtSGZZjhbj
+CQmmmmNQRPvjgRClCvmmcVHPqMFMFsWJVqFFcnTJ
+QHHqvGwjjWNqvGTQGvTFcGwJRJbszcPtDbJVbtPzVbDptp
+MLdrgmSgZZdhdfbLVRpszlRDstRL
+gdSgMCSfdMnrghCWGRQvHwvNHjnjvv
+RDBZwvZBrMlsvnlb
+WdFQqdjWWcHHPrwSPnnSWnSS
+mLdqgqHmcjHHjqLHjLppmhfBfgtDtBJZJfVtBZwGZB
+CCWRJQnZlHtHtNZRFDcBhrcvhDrJVVDv
+dPPSqLzfsqGLSTzfLzLGdLMVVgvBcmgMVwmmDFrVgmBBBr
+SFjdTGzqpjdRbNRNnjtnQR
+hjNcwBDDwDFcjdFfjtFhtcRsGGgTsGRRRTsGGqZGRq
+gbmrLnbzLmvQJnQVVpqZTqzWSCRpqRTsSR
+MQMvVMbPQQHrQMnMPldtwNNfgHtlwBhdwj
+zwzwpzMfzrBMWfCCZrwzrMJDGGGnNmGNZvgNZsDDsGsG
+FbFqSbcSbSHqTjmgGFnJglllsDJm
+TbhVdVjqdtqTjVHqjPdthPBBWpCnRfwRPRCfBCCnWR
+hlpmbfJJpCSChmJMmrSjTjcSdjTtQQTtTtjF
+gqrgsqLzgnBgZGzHBnnsQNNQtjjcNNjjtNFQNcNH
+LVRzgGGzzzPCVrJMbPJb
+VHrmqFnVdvlzzNrr
+PMtwBJPBcPwfbwBJndplLvLdLlgMMzLL
+bBZnTwbtnScfQJPJwPTjqGZFsVFjDHHGhhHhVj
+cftqScHJrfVfrrRZ
+DTTsDvvlBbTGrWBwwsWDBbWdVpZjjZjpVPPGhRRVjVZNRPNN
+lsWdWDbrTLBsbdrmdwbMJtmHMQJccFHFnJFqFt
+SWNPTPVSWChCSmQQhpppJdFJLpDpgLJmLd
+NGGtNtGfHtDpdJdqLB
+NcsNGNjHZsZGnzZfnGhQnhPClrVlQPhTVVhl
+QDdgMBsNhhMgcWbZdzmWLzFzWH
+fRqRJJqGCvrJGjCRRrSJlfPtHzzPmfFbtPtLZZLnmt
+VjvwwjlwVGGqJSSqJFccshpgNhQNQTsVgBgT
+wvDLDwCbFgSTfTSJJgfB
+qsRhmhqchmVhPdfTHJSzpCtJpfPf
+hmdhrWrddmhlqCRcwQjDLMQnMFDZnlLl
+trMWtlwwMplMZMCZWltDpzBLBnflVLBbHzbBSGlVlL
+ghhqJTfmjQjfqqznznnHnBRzBLmn
+sQhPQsjjQcQcTsPqZWwwZcFfWrWcrZww
+MRVpVCZZTHWVMCHvgNvVvbQSqgQSlg
+NFmnrNDDfnjFnndfssmcStvjvQQlvzvllqvwQllj
+GGPNmBrFNdcfcGrsGcdmDFhJHMMhHLZJMhpLHCMMMMPJ
+DSvDGdGFlGGnDZFdVSZvfPqwnfhpnrqpPNpLPrrh
+sWcTjtHCsTmsCNfgMPjpfPhqhP
+BtHzBzChzBBvFSDJvVzFJJ
+sfsNrsFFBTfjwwtNNWHPVCVWtSCDDCDmmS
+zMdhMMZnSccMmmWVWmCPlC
+cLSScJZQbcvLhZvnzBwfTjrpNwNrBFffpb
+TBrCBgrTngVQBVbhrCtgJJrGssGsMGRGcjMcNjfN
+LZdSLvHMFdzFRWsLjcGRWWNJ
+pHpzlqPqFPvdBthgMbVPDhgh
+SZlnZZvBvvMrcBnllBMZSvhGMtQwFMGztthfwQtMwwPf
+HLqsDgNsDLDDDjggHDHszthzFbQGTghPGQPbTfFT
+dmLqDqCmFNjJsjHdssFNHDVWZccnRllnVZvRSBZrZlCc
+SccnnSGGftShfHSHHhnvbMjvVlCjzbVzzbMMTbCB
+gRpppNNQLWqZgPZwNWwwBMBbDlZCTzVTjHMMbBjV
+dqNQPQRqrqpPcGtchhdfhHSF
+mfDzgnNMMszBtJCpHlrjnFppCdHj
+LLRThGGZcbClBQpdWFGl
+bSqVTbBbMVMsNmNM
+BTTbbLVpfchmjbsj
+JSQJHDMHqdNZTZlhFFhCFFrNhNcsrr
+tMwJQlwMMlQwDDJtWGLGPpWLLGnTPn
+LcVQQCPPLqTzqQTcllTzhnHHfFJRcGHcFfwRGHwJjJ
+stdWDDBtVgbpWgZbsNgDNdWFGMnnwHfjHFpfwwMGMMGRjJ
+ZWSDtgNdWNBdgsdsNDDsdbDlTzCVSTCqQmSqTQSvhqLVQq
+dZbgdZbNtmqttFJtHHzcczMcFszHnsvH
+wwpQplQQwqVVjqwPjCGCSMCMcHSHvvzHMzvcsrMc
+pfjlQRpPRRLQWtmLNdWdmqqJ
+CPTPPmbjmVjVGCvzbjjPrGsnnMpttdtGdncdMccDRd
+lhlHzQSHwzhJLwgWgpMDMMsDdcDQMDMMns
+BHZghLWwSFBJJBFvzmbfjNZvZmCvmb
+PBGcvvcRwpwNcZcNPpPNcTHGdMtrCWrCCtCLWMtWgbVdMV
+fmsJjnqmmfsjQJnjFzSFSqsqgWrtMttZgMWVMbbVMdbSrLtr
+qQjjZFmfjZhZmwcvPhNpTNBTwN
+HHlVVmmsbbqMsJmVzGSBMSrQQrRrGvvnDn
+PZcphZPPZPhjcpdWgPZhRPfcDSrtDBSGNvtggrQtnvQNGNDn
+dcWwFjpcPhRcCpjwdCPLzHblJbLbzmsmbTwzqH
+hRfzTTfRrTGzhGWTrRrbfcQZQSttWtwddJtvdJJvWSHq
+npjnDjFlpDnFFNMjljCnFMQtHHtqNHNQJwwZZqstNwJJ
+DCjpLjjpVLDMDpVLDLQbbhzBhVrcVgVGQQcz
+LncLBLjCSNrNrNpCLQBBBGwqQwzlzmggvqRqgllmzwtv
+fMZPHhhHfthMdbRgHJzmVqlvwlwg
+hfsPbZFPPDsfGLcBtSFNBSjL
+MlZmszBMJBHrMBMbShwSFpbZSZfwwb
+TCLCcPNGTgTPNGWtCtcWtPcSsRfRjRwjFbfpNFDjwsFspw
+nVtqqsWsdHzJHqmM
+RCrhSmWrmrvmrvhMvRNrRCzCJcQQbPtsMZVGJJtsZssPcQcZ
+jLFBGqLFpqBLgZVbPbsLJQcbsV
+HjDljGFwrRHRRTrS
+GZZhnrwZBwNjRPRCbCbn
+fJtJJpsVfpgNTbVNFTRP
+JJcpLJfLdcWLdplwRdQMBvSqwRhvrG
+wmZDPlRlCDwglgsHtsBvdBHLFLSddr
+VbVMnMftfVjQWFFHdMBdBFMFHr
+zfjtnGqqnjGqfjPcDPlZPlRDzccw
+BRjhfhvRgnTMlFDDJfZzZFFQDZ
+qLdqcNttwwcwwSPSpqLNmrwmrZsGzzDFZGZFzVssrzJGnsQG
+wSNdHScScdmwHSpdNcmmtLMvChRHbvBMTBnCBBvhvlCh
+JgWTPfFPgCPPlCntQSGghHvQnSdQ
+BzvMZvLVQpdQpSZh
+RwVVjRDVcRDNDTlJPqTv
+SGHSrBBRPhPPHQcTccQTRRQjTN
+vvWvspCbzWVWVrWdjj
+wZpDzCDgDbCZJZzJGlrlqPqnqPllmH
+FCncCrDWMLCbjMCcFpLdzZfmZzwwWzdzNRZdWB
+sqsgTqHSqllNldMwlZzJ
+MtHPTgQhvhhqcrDrrDpjLCQc
+pPPvmPWSClqqPvqCmSwqmgGBWDjhGLHfjhDLJGjBBhNj
+zrbdcdMndcRdTrsMcbTRdzRFVHjLjDjNLNHsfDhNGjhJNhDj
+RdFFcnTdZcTrRRdFFbZtwQCPQglvPlwJwQPZSqqP
+wlmbvwmvQvWQsvmbsSsQbswlRCNPfCTcTRVCffPtTSCPNRVP
+FhJJJFgFqJGBtDpJhTTcVcVhdcCdCdTV
+GDFtgLFnqqDGqGZsQvsllrjbLjbrvw
+lnFSnJvmgvLlfnJpgnsjnjgfDQWqCJqZdDtDCtCtCdDrtDDQ
+VTBBMPFcNNtMZDMW
+VTGbzGGhTbTGHwVPvvFnfpvjgHnfjppp
+JJwHqvlvDjljDwJFlZjZDwHNNsMqhNpphNpmNVzpsnsnRV
+mTLgrLLcLSTTTdmPPfrrrnssNhRNWhgngzMWzgzVnM
+SmTfdSBbBJbtjJvljl
+bPNLwTCLLQQqtJsf
+zdnnZVlWWGGRWGWdgdSStQMqJSMRptftbsMf
+FWbvgvZZZZgnTmwrrhrFPCrP
+HcGzzszFGllHWHbZspHbHGsHTwwrTrLLCNjSZwNjNjjCCNLj
+PBJMJQJDDDnDggRhMdRSLmjTmTwwVjVQSvvwvC
+RqfdhgDPDJDqJJnBdfzWWHcstslcbtStfHzl
+zvRRlCqrdNdZcZpjBpVwjsmjsm
+fgbTDqbhGfDnLDnLLqLhFmsHpTPHjHppppBwpwws
+nhnnnDDngDtDbfSbDnGhhgRlNvQdQqNvQvtcQQNJRNJN
+cZbCcbbScCbcmPGjPfSBQQSq
+lnMnnVsMVvmzzGMDzPDf
+LhrTsTTglrnsrrWWVvlwTnNtcpZRCmhtbCZFdttZbRCp
+NWrFPZVWNVrvvrhtnNdddtpldmjm
+DcBQBDsJbCwQnbtdzmjjjljbpjbz
+qCDcGsDJGCcBDBcswJnBJQDfWfqgvZSvgZPfrVSWvPvZZZ
+vcsdHdGtHtMHMFtVsddsWCcbppZwjScLpWhbjRWR
+NTwrnzJrgTPrDwnlphRpjSpWbJJLLZWj
+TlDPfPnzzlzTBzzvQFFBHMtVtqBqqw
+NHnqqfZvZBNHHvgfrSlJrJCSllJRVrCn
+TDTdhLMWjFcddMJPSSPJRmlCPz
+bljWFdLLTDLtdFtLlwZvqfbgwwHfwqHNvw
+BRRjhRQndRNVqBjRVhFLccjpwMmLmjHmgFHH
+fZJfJvzPPWtWWlltZzZPpcgFMsFFwwFdpHdgwtdw
+PCrdrzzfWCPdvSlqTqNSDnnQVVQQGT
+DjbfBMDSfBljBsLSjSZbzrGtPtMCPtVPvvqrzqzG
+mWdJWcppcNTdpppjzjRRVrPRpq
+QncmnHwmdTmwQcmjNTfgfhlBShshhsffnfbB
+WGDsMJsrjHCWtDMGDDVQqSvZqfSJzSnvnvvv
+LgLFLFBFLVVzfBzMqZ
+lgmFcwLhNcwdwwMLwhmcRDjNpCWRsWRspGGssHCp
+PnPzNccnjFfvCvhbSBVcWqdhSVhV
+psGMDQJDDDJgQNDHHJbwqwBsVqqZVWBBhBdd
+DlDJDQGptpgpGDfTRnrTrFPnNTlf
+MSSSMLLmFHcDScSq
+ppZnCsbjPZpnnJcbRDmzHJqRRD
+pmNmnGnQNnClZGMVMdBGrMgVWg
+lsTTGcQzBcljCcQzGcGjGptttpmvSJtmggtwwswwtS
+qZRnrhMbRVdhZRhhdnnVRPbmwSNwNNHtmJBvwpvtwNSvSb
+VnMrqrrdqhZrnrBLLlzzlQjQjLfTcGfFDF
+dJJTlHvhZqZlQTJnSgQDzgsSbScsSBzc
+RRNtGjCCpRPPpRtjfrttRzmbscLsLZLgcsbmLzSGLB
+wfNttfNrtWwPNNFfRtpfrdJMTTTZTMZTTVTlVwTlvM
+PQTGLmdNTgPmGgNNdCPLQlrMqBrDzMCMFqDqFqjVCBCD
+hhRwwvpSFmzDrmFh
+vwwZfSfsmvtSspnZLLLdLGWPTGTQtTWG
+pMcWzWFvWhFpPMWzvvhpdprHTZTQrHrQdZTJdfTgQTnJ
+CGbjBbNjjDmRHJDgrTVVZg
+NNttGlGqNLsbtlhMFMFcMLwMvvZz
+CGSCBNCQBtBCQttBwCGtGtQrqrLrJqZHLHbqHvLDHLrq
+nVVhPMfVdfVPbfqLLqgDDqPvgZsv
+cpVncbfnhFcBltTplpmTBC
+MrdcdStbMnddtRBdqMnFmbqGCwqCVHVsNHwPfGVPqsCsCs
+DBLllzWWQQzlZVVVCsGWHfsH
+JQphjTgBjlLgjjpTpLgvTjQnnnSJJRRFmdbRRSdMRtmdMc
+QbRZMSWMblwLsgpwZzqZ
+BFncBrfcdNrrnVrNjsFzFTJpJLGJsGqLTp
+VjhDDBdrfdhQMllzHmPQMh
+LdVVjFVFbpVGRQGllG
+cNMcJNHzJWJtCWHNJHcHczWpGmmhMQmBBqrlRhBmpGpGBQ
+JZzTTtCZtHCJnNnNwPfbFpnfdDdLdnvP
+TpMlrWTTddjmlmDmgQgRtw
+MNNVMSsVSNSnNVMFLDqwtGgRRtGbgFRwtR
+CCLSCPSCZZHVCfZscBJJhPphpdpprdhjJM
+gSMSHJHsMMpzRgHzsRMPPSzsPhtZtZdqdDqQDhdCdZmQldht
+FCcCnrGcNTfvvtqqfvlflQ
+TrTrWNWwrTJLMzJCzWLL
+TpTzwMrfbrpFpMbFrrrzbPSdZmtSZRTlTZRlmdCVlCtJ
+vqvWgqDJQJsQCVtZgdZdRRGd
+vsvLJLchWBcqnvczwjLfzPjfrjzPrz
+zqzbqCFZgmzzmNmf
+vpRWSbRVbVWddVpwvwdRSwnSNgLHsnfNgMmgMLMmnrns
+DwWVpJRlpdbpRDWdGJGcGlhFtPPCqCCBFqZPQttlqFBq
+wQRlwtBJBDwttJdGvLfBvHLLfTLz
+MMmNZcMrcMFnRHzfjjvvHfvc
+FggpbFnhrNNrrMrMbMbnhQVJVhstJwqWCVCRsQJQ
+DQbCGblQlpQFQlHjCbjwDQQMggNmJmgnnpRBngfZmNgJMf
+zvhWccWVdWBchdssPrrWZZZfmsmmmgsnZZJRsRTf
+zBdtqPccWPHFCqCCqljq
+ttrbRMmgtHgfmHSfBpLfnBBZBppB
+CVTJDCCNPwCPDwcqzmddQZdTQdnLBQThWp
+zwFDjwDJJPzjzVNcVJwCcbRHGmbbMrFHgHvrsgbblG
+gZjjwHqHCzrMZVVR
+hhzcdTzPrVhVCGMb
+fPcmLPNffsccJDdNDjBnpwzmHqgWjHwwvg
+SJQFSvQBlzbSCgdPPddPPPSN
+pcrjcWLwwcHcgPNgTPLMNTCB
+pRsjsWRnrpHRmrBrHrjlbJFvvzQFnzQblQDDbJ
+VjQVMQPVMfVPPbGPHHbGJD
+pcqSttltsbDGddsCJG
+TSchqLtTLFhgQbMMQMrr
+trqzMRwNTtDzLPJQgWmjmjrf
+lbBQdpZbsmhGmZhmmG
+llVbpCplvvHBBHpnRDcDRRqnRRQnFRzT
+SLSSFFmzLShsVSSHnLnrJdbnRdZZbrRw
+qCfWBftpNWNNlqvTpwrRbGGCnwGmgRJGZn
+NcTBNpvWvBWpMftNffpqWlTpmzPDQPSzFVMsFQVhHsjHszss
+VtJtNBRBGDpdpNbC
+QgLncnttvFcwwhLvFjSGsSbmmQCSDdpCmpdG
+vLgjLhhrctMvLFFjLtMTLMgfPZqBZPZzJBBfWZZPRZZTRV
+mJzDJJpJBvfsGMQnBM
+CwPWCLRRWwRqwPqhPsrZrnrlhhQrMTrvZl
+dCdLLSPRLSqWqVSLqLjgJDzDmtbngFVtJtzz
+mtgWtMWrqjzQTTjghwwfczlNJdlcJnlc
+FvRsDPPFGRBFvvslwDnTlcTTdwndlh
+SGBZRBTsFGBRvLpvSCmgQWQjgggMrQjmmSmW
+GcsRrQhrVVjhRcWlnDFGGmvntDWZ
+TPbSgJJgBSCbCTbLHMCMTTZdFHvtZlWZDZFzmzZHZmmF
+gBCMCSpbPMMPjcjqQQpqQprv
+nZJcnZwvwzvTTTVtpDFnHH
+DQPBqGGGdMdTRHRBpNgFNR
+dCGPfhPWQdWWWCWShWPqrChWLLwLswjcvSJbvbLjJLbzJbJD
+QrBQtdtrQBrdtFHPrdQBDvGhLGnPnCWnmpDmLpmD
+NjlRJRlNzJJVbSSRVZwwJcmpWDGCWnbchnLCCmnWCG
+llSJzsZzMMlsSZjSjZwJNQqtHHdBFsqdfTHhqFftQB
+zdTJFHTdDBzrNdMnhNnNdM
+ZlLZZcLtVtcWtGjtzLjLZjCrnVNrnRbrQQbQSRVrRnSNqS
+lZtGtCvjZPCGCctPpsDDBzTHFmPmFszD
+mQSMvdMQtQdZhQrPWCPqPQrN
+RwjwnZGzJFTZgzggzJDDwJnCPPhNNqPrLhrGNcWcWNPqCq
+ZTzDfnwFzTngTwJvfSlMtMMlmsHmHt
+lZlmFRVZWmgQWhRsRpJsCJpJct
+PTbPTGTGwwGrbdfjNNZJvcCsCZtvpTsh
+bGdBBqGrdBPjDMzzVFZgqQzFFL
+szvsmLvppPPtzGLGWpVdTSHTNgjHQRmHTgSH
+FnBMBNZwZNcnDZMcnZlZgwgdQTTHjVJjHHVRQHJj
+DnZrFCMZMNffrLPbLsfW
+rJvmnBgnrCrGRSGNQR
+hthjNfhwctwpjTLtVLjTGSpldSCGSPdlPSRzSqSz
+TVcTfHNFcwtjMhTvgbHZsBbWmmZbnH
+WsQgstQmvQJnssWsWPzhRzhBjZBSBRZSnj
+qwCNqFwDrrlDrFPvRhTSPPzLRz
+bppqwppCddlvfbDNVgmMmtMfVVmfmVWW

src/lib.rs

@@ -14,4 +14,5 @@ pub mod year2016 {
 pub mod year2022 {
     pub mod day01;
     pub mod day02;
+    pub mod day03;
 }

src/main.rs

@@ -84,5 +84,6 @@ fn year2022() -> Vec<Solution> {
     vec![
         solution!(year2022, day01),
         solution!(year2022, day02),
+        solution!(year2022, day03),
     ]
 }

src/year2016/day01.rs

@@ -1,4 +1,4 @@
-use std::collections::HashSet;
+use std::collections::BTreeSet;
 
 use crate::util::{index::*, parse::ParseExt};
 
@@ -29,7 +29,7 @@ pub fn part1(input: &str) -> impl std::fmt::Display {
 pub fn part2(input: &str) -> impl std::fmt::Display {
     let mut pos = Ix2::ORIGIN;
     let mut dir = Ix2::UP;
-    let mut set = HashSet::new();
+    let mut set = BTreeSet::new();
 
     for (d, s) in parse(input) {
         dir = if d == b'R' {

src/year2016/day03.rs

@@ -52,5 +52,8 @@ fn test_part1() {
 
 #[test]
 fn test_part2() {
-    assert_eq!("2", part2("100 200 300\n101 201 301\n102 202 302").to_string());
+    assert_eq!(
+        "2",
+        part2("100 200 300\n101 201 301\n102 202 302").to_string()
+    );
 }

src/year2022/day01.rs

@@ -16,10 +16,16 @@ pub fn part2(input: &str) -> impl std::fmt::Display {
 
 #[test]
 fn test_part1() {
-    assert_eq!("24000", part1("1000\n2000\n3000\n\n4000\n\n5000\n6000\n\n7000\n8000\n9000\n\n10000").to_string())
+    assert_eq!(
+        "24000",
+        part1("1000\n2000\n3000\n\n4000\n\n5000\n6000\n\n7000\n8000\n9000\n\n10000").to_string()
+    )
 }
 
 #[test]
 fn test_part2() {
-    assert_eq!("45000", part2("1000\n2000\n3000\n\n4000\n\n5000\n6000\n\n7000\n8000\n9000\n\n10000").to_string())
+    assert_eq!(
+        "45000",
+        part2("1000\n2000\n3000\n\n4000\n\n5000\n6000\n\n7000\n8000\n9000\n\n10000").to_string()
+    )
 }

src/year2022/day02.rs

@@ -1,13 +1,13 @@
 enum Move {
     Rock = 1,
     Paper = 2,
-    Scissors = 3
+    Scissors = 3,
 }
 
 enum GameResult {
     Loss = 0,
     Draw = 3,
-    Win = 6
+    Win = 6,
 }
 
 impl From<&str> for Move {
@@ -16,7 +16,7 @@ impl From<&str> for Move {
             "A" | "X" => Self::Rock,
             "B" | "Y" => Self::Paper,
             "C" | "Z" => Self::Scissors,
-            _ => unreachable!()
+            _ => unreachable!(),
         }
     }
 }
@@ -27,18 +27,21 @@ impl From<&str> for GameResult {
             "X" => Self::Loss,
             "Y" => Self::Draw,
             "Z" => Self::Win,
-            _ => unreachable!()
+            _ => unreachable!(),
         }
     }
 }
 
 fn calc(input: &str, calc: fn(&str, &str) -> u32) -> u32 {
-    input.lines().map(|l| {
+    input
+        .lines()
+        .map(|l| {
             let Some((l, r)) = l.split_once(' ') else {
                 unreachable!()
             };
             (calc)(l, r)
-    }).sum()
+        })
+        .sum()
 }
 
 pub fn part1(input: &str) -> impl std::fmt::Display {

src/year2022/day03.rs

@@ -0,0 +1,47 @@
+/// Number of trailing zeros tells us which bit is set and there should only be one set
+/// Do some math to convert to the needed priority
+fn bits_to_priority(b: u64) -> u32 {
+    let trailing = b.trailing_zeros();
+    match trailing {
+        0..=25 => trailing + 27,
+        32..=57 => trailing - 31,
+        _ => unreachable!(""),
+    }
+}
+
+/// For each byte in the string offset it towards 0
+/// to make it fit in u64 and set a bit at the position of its value
+fn to_bits(s: &str) -> u64 {
+    s.bytes().fold(0, |a, v| a | 1 << (v - 65))
+}
+
+pub fn part1(input: &str) -> impl std::fmt::Display {
+    input
+        .lines()
+        .map(|l| l.split_at(l.len() / 2))
+        .map(|(l, r)| bits_to_priority(to_bits(l) & to_bits(r)))
+        .sum::<u32>()
+}
+
+pub fn part2(input: &str) -> impl std::fmt::Display {
+    let mut lines = input.lines();
+    let mut sum = 0;
+
+    while let Some(l1) = lines.next() {
+        let l2 = lines.next().expect("second is guaranteed to be there");
+        let l3 = lines.next().expect("third is guaranteed to be there");
+
+        sum += bits_to_priority(to_bits(l1) & to_bits(l2) & to_bits(l3));
+    }
+    sum
+}
+
+#[test]
+fn test_part1() {
+    assert_eq!("157", part1("vJrwpWtwJgWrhcsFMMfFFhFp\njqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL\nPmmdzqPrVvPwwTWBwg\nwMqvLMZHhHMvwLHjbvcjnnSBnvTQFn\nttgJtRGJQctTZtZT\nCrZsJsPPZsGzwwsLwLmpwMDw").to_string())
+}
+
+#[test]
+fn test_part2() {
+    assert_eq!("70", part2("vJrwpWtwJgWrhcsFMMfFFhFp\njqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL\nPmmdzqPrVvPwwTWBwg\nwMqvLMZHhHMvwLHjbvcjnnSBnvTQFn\nttgJtRGJQctTZtZT\nCrZsJsPPZsGzwwsLwLmpwMDw").to_string())
+}