2022 day3/rust: use bitwise arithmetic

2022/data/day3.expected

@@ -0,0 +1,2 @@
+8252
+2828

2022/data/day3.input

@@ -0,0 +1,300 @@
+QJRBMDMtRDCtJzBtJMfjNjhwvmNDvwjLVVgh
+TPSNNPZGTjgmSmvfjL
+bPlpZZbpsTlTsWprpGFCJtRtzMNdMMBBcWnJQB
+tppvbQBhpQQdrzMMcLwhMc
+gZnWRccRNgFGRGRFRNNgZgJMddddLLLMCPqwLCNPwqPJ
+nRRmFSnWmlgZlTlTllSlSWWWTsfvfDQpBfBcpQvpVQpTfQQf
+lRlsVFgTlMgRNsSNTlFgmbWnMPppPnMqWZMWPPWW
+fDjgBJdCfCHHBnfLWpqnmnpZmf
+GjQHHcdvJHQBHSSNsFQFslwwRg
+NPwDLDHNwjLLHWjbdSbDfJJQTZsZDS
+BcFBcvgFvghnFLrBpvrgcgrJSZJpQdfSTZbCsSdfZZfbCf
+VrngVFRmrVWHLGVMlL
+SNBBBDlfZDLqNGmgFjjmBsQgCFtF
+VPPVbhpbhMhRhncnScRncbrQtCgQQFmjjjsgtRtQHmFQ
+nhWcPJVhpbvMvwvwllvSlGlD
+wNlNNqtqHHHPhqCz
+MMMMcQSWSpQCWFnRRPchLVvPLLzhmhLzhh
+CrgRSWrnrQpppRQrCTnRTRtGtBDBfbNBllbTJlZtfNBN
+QNbbNrnNnCwHmNPQmzqQNPsCCfBFFGtsBBddBDtCJDJd
+gvVgpZWgTWvRvlvLPDDJjGBfdsdpDDJGdd
+ZRMWWRMVgRZghTggPSMZzQwwnqwmnzhNnNwHcQHm
+VmPHzBmpmQHbVHSpNHBVQCtRPPCPvFFMqqntZCZqMR
+dWlDcfcfcjcfDWjlsZfjJhdGvFLGnLsLqsRnvRvRGGRttC
+wfJhZTllcfdZdfjJfjdmQzHVSzHzgHQTpHpmpV
+qNnqmzmCBfvmDvBm
+HcdhtQdttbbhtVcrVVDMfZvdMBTqsWZMBsWZ
+HQGtctRblwqpNwRN
+SBtBLBMZzPDDNFFDQnVVVnnDmf
+dgCjblRdgRvrbwjJGzQQQzwJVJ
+WpWbCWWvlgrcCHdvvCdvWbSLZzhhZhtLBPPStSPhMSpM
+PlPnGGGzCqqlrqTRsbTmFRWgDPmR
+wwpLtjwpzjDwFWRsWTWW
+NZtJjHNNhHfnCBcJMBlCSz
+wSrwggPrhJhCdddw
+tLMNvMTFhDZdhTBh
+LtMvFttGbNcWRsLFLsccRRgfnSrPjPnfljSfPWlnPhrS
+TSZlwZSSccSHZLHVcllSvmDLmJhjDDffJmGjQjgQQJ
+sdBdzsNnBMBstNNMFhNPNbPzgGfDgJrtrfjCjDrCfJmmDQJf
+BnnBznRsFRFBsspzzbZpSTqVTpHVhpTvlqVW
+VtVjjhdFmCCfhRRzzSDbDzpmgzmvgb
+CHJqrswsWvbvJbpD
+CqCPcZHGHTcsCBQsBrTGHMFnLVQjMjLVVhdhnFQVRL
+tvlPSrlNNvtglTtPccldQdhbQbZdcqqZ
+mRmBGHWmDFRsZqHrfbdhqhZZ
+jjMGjWrJpttNjtgg
+HPtCMJNjvJLMDZRdBgLSBSfsWBgG
+VmnrhwwqhbbzrwnDrqpdWBgfdSdfBGgffGWRdh
+qmnTFbVnpqVzpnvlDFJZDClNZPZN
+NNRFQfzbNWhLHTVh
+dGjptnrPqgvqjccvndnnPPhlHrVVTHLWMHlwmrlHMmVTWm
+tDggGnPqDcPPpPpddjGhggtJCCSssfJbQsDfbZsbsbRZFQ
+bqZWhbvvvqfvhqvQCChhZlllGwlwGjNRrNGrwGwNRQ
+PmspSscJVJStzSVzWJlgwlwNlGRLDGrPgNwN
+pdHmWMVStWJWFBBCCbMhCfbC
+wtwbctGLwGWhGwfWwhNrnLrlrQFNmPNNVrrl
+CSdqZRsMStdJMMSZqPnFmVqPQlnjNjqj
+TMtsTBSSRZBCJStMJSZTHtfvpgvzzWwhbpwhggbzHpbW
+HncMbCwCncHlcbMDMnMFGsNsJVFJGchVTTcmcG
+RRfBRNjRLLJTLTThsq
+zpBRjWRrRvBpNtRWrgwbrwQPDPMDwCnn
+TDcPLTVRjntFwDwDnb
+SJJhffHqHZZgHGSFFbdrGTGnGv
+NQHWZgJQHNHgHQhlLLLBjpRTjLjMNNLM
+sMNnNRNrlGlsZBrGsrFQpclWlWLfpWjtzTfDtpzj
+gvhPgwTgdSHtHDtpDPLp
+gwhSwdvTSTbSgRrZNrrNFFNBGb
+rtZnDHJrrDtGtGHvGHDWfdfwCjcBhjBCffwwLv
+lzVlzsTRsmzVNTspVsMMsmwCLcmjmcdbBBChwfBbCW
+sVTMpTpppsVMsPRPVzMNFqMFwZtQrHZDGqgHZrSQQrQQJDGn
+wGQQMMQvCTPPQnHPBS
+FsWdJddszWrrRRJRTmRmpppRHBNPBppNHp
+rWdFWlFJzbzzMTwcvvMbGMgc
+WTnnTpqSnCLmjGgSgjztgg
+rQRHQvbNLwrgtGtrmDglJt
+PwHRNvQPsvHvPTTpLTcCLVnq
+qTsqJDJHjjfMCSDj
+RnGGNFGznzGVnBCWmfSMSLwWRwSj
+NnBbVQFVCClctHQc
+BHzmfDHfJLGcQBGgQLDcstNttlZgdlltldshgZZg
+PwPPSJwPvSNZlvSl
+CJwwjnJFFnWRMcMzcHMHRzGL
+rmZpvcZcqccsqmqzzzcBRLBZbBBRLBlRGVdfZR
+PwjFggwMDgNFwPgTwNFgtFJjfGLhBLsGRGbfBfBLbbTVLbdf
+DWJwgDWMJJDWCCNHmrnscmqqcnpWSQ
+bsRlVgMhtzHvhRvpzcLSZcTWLGzTTrGc
+QJnDjmqjJdmDqqrGWWsZsZTc
+nQPsnwCJdBDJDDJvhHhpMRCVlhlgRV
+NBNwMCtNgqCHClHClq
+JpQmFrQQfHfWjJTfLTjfLRRFRvnvhvnDGDcRcvVGGV
+HTzzpzzdHgbBZZtdMB
+SWcVvBFBVBjShWhGQtZnHFDHRGGQsR
+pMZpmmJPbwbTTQttrDrRrttT
+mZflqdlbMVcNjdWLSj
+tvjdccdbLjhvhlcjRMvRTCQJmBPBCFRG
+qgnqZfHpZDVnCpZzZJQFQBgmmPFJBmRQJQ
+SHDZDDzpNVpfsNsHqpDSjLwCbbWLChwtwjtCWc
+FsWTbcwmGfFFFrpl
+LMhzdfqjLdHQQnSvldGvnS
+VZjVNzfNLtjzDMhVDNtqDqwJwRmmmZJgmgcbWgRRwCbJ
+ZJbPwwfJcGlwCrrZrMMddMMMtt
+pTNvvSSHmmnbpFRp
+SLSjSLDSQNLHNDbJbcfJclBzjGsz
+WSQCWQWstCWCCgNNsDCZMZDBjjlLPnHMMLPrHlcrcLHHTjTh
+bVFJFwfdRFFgjTPgnc
+GmzRRqvRddbdRRdfJRJfsqsSSsZDsDBQZtCSgpgt
+FPjprPpPCCFpFPHWsWvqnnllQsdLQMMlLtslLQMc
+wmzJgzRSRRJghBbwGBBSbtGfLfGlcNnlltdddQtrMd
+zDmRBmwDrpVFDTVDVp
+FPGqjsZGlDJmzsHcTcTMMs
+SQNLSvdbvVbrSbHcftGcrpHGfMmf
+CNNGSCCdSCZqjqljZF
+GvqpqrpqdqdsdGshSMhhRsSMhhlSlJ
+DLCzzjzBwCbQWtQlRRFRRJFptfffgM
+WzpLbLDbBcLPjWQWDBzzmnvNndHNqZqZNZNvcrNT
+scHCGfWHsvWHVfGsggHfgvVcSLwLLPRwwDLPLllRPDzlPr
+tbjqqNNTlPDTTSrD
+QntmNbNnnddqJqqbFJHZWWHWJWvZHGVJsSsp
+WZjpjwwGBGZQsqBLBHLHSRLP
+mJhtdfVtDVJtvVLSmNRSccPPPlNHcH
+JJLCFDhLCfVGGwbGGCwrGC
+nBnsGSCrptmsLWGhWRvVRJVJ
+rllMZZbcWWLJvhTl
+MHwzczHwwHqZcdzMdbqSmwsssmtNCrBmtrnQNB
+LzwrZNrNzBMrJBzJsfqqntMlVlSfhnhb
+HTDPWDHPTgGHWTGcPFRgFpPPtfqmsfqlccmlSmnblbshqnmm
+jWGgpRGPFRHjzdBBsrBJvj
+hjNghjlwqjzGhwhGwLrMMrsMdsMfczPfsr
+ZJQSFZFZpCTQSZHTTFbcWWPbWsWrdLVmrMWMfr
+tttHSCpFQBQQpJZSJLgBNNDhqhBqvBvvRq
+hLLJJJLcLPLfLwcJDchfhpSmqGbmdQGmGSdbqdbmqGGGdG
+zgCCVVvVCNVssdbqmtMWvbnndD
+rCCZZCVTjVZNzFZJBlflBLccDhBFFB
+wwPPHfCMHQsrcwPbMPMcvQFJvqWgFTZgDFJltgZt
+jRBVLhpNqpBmRhhRdNJZJgWTBBtgZWltZJJJ
+mSjndhSzphjLRVqmhphNShrGMGrcbGbnGCHGwrwGfbbG
+PVBRhBdlwRtRhRBwtBlVzDcGpVcZnggGzGMMsg
+fFFWQqbFbLWCWvvFbTjjGnsZMfgsZcZzSZGMpSgD
+QJTCCLFFLjFqFbHTbbltmhBNwwcNmthNhlHr
+qwPJJsJdbPdwJddQCRCgCTMTRGGwMG
+cLFcFBZNWWQLSQRfZjpljTGRCgGR
+cFvrcNBFJDhzdQzv
+zTsVTqDqQNtNwwMVmN
+pHpSzPbRrvbRrGzGMwZwlBJmNtclwJpB
+SjHRPfRbffPHqzCCCdTsTzqj
+jnbMBnPjjjFtBtMjFPRtGfvvfzgWWHMfWHTlGgHH
+dCpdqrVrmdpHfTJTCWGJgG
+qVdrppqSTddqNwZcDPPPhZRBPBLBRLjF
+VbHqLlGQlgjLjjQsNvCZTsNjMtCZvT
+SJtttppwwpwBwdPvsvCvBZrvNrTrvM
+JDnWJpDSSpmSwmpPzSwznhDlqGqqtqqHGHLlhblGbR
+RqRJJVMPdRVVpqMdFwmvnSMwZcfCGfDSZc
+CssQgjssvZvjffmS
+zNlbbWTBLWCbCPPFPbVH
+nvQsHSsGvNvnQghTRMrrjpjM
+ttlLDlzPtGDcRRtpZTFjtgMj
+PBLBwPPDzzLwblzffzLlVHHsCCHqsfvCCSsGSNWC
+jHrTrThrtHgttThgHTtfgTgsmZZmBSZGSGsSGfZBZFFmQs
+qCCPdbcCJddbRcsQSGhFzmZqZGmq
+VVNNdVvclDcPbMWMwnnlwhphjp
+ZdBgJqFWNNNqnZZNGsBCCCRvrCwCjCssCB
+htDPMSPtMPzPTLMzMTMbRRbTbvwRCjfRfsbWWs
+LhMmtMDWmHlpppplJZJgNd
+mhtsjtbChcpLqmpmzL
+DPlPprrfBrpGHHVGNVHRqcNvvLLqLcvJzzTvLc
+VFfVPrrBQFPlDDwDwBpBtSgQjnghMhCdbSnnhtMM
+DPDMpbsHPDPNtdtrgMtdnQ
+WShWlSCJVlzccSBvBvhVZZWlgTNTrNrrQTjQjjjjgDSgSdNt
+cvmCDvCJCcsRbmpFmqms
+sSfFssmLnLwPtrrmttsFbDvWgCvddVgfgWdRDWlChD
+nnGnHBzqHjqBJGChlRClhvghJWDd
+jNzNcczMcGntPMwwSsSr
+GGPCThCCvCTVWBCBGMVMsTgZJsrZtHNNtrsHJrgH
+zjRwcwwfvSjmwznfzQSHDJtgrNrRNrLDsRrHtD
+fjvzmcfSlSznwcnmnSQnhdlhWBpGpdBqhGhqhVPd
+sHGGqpRqfNRVbDDtVwwzWf
+CCLQZllTQLTcSShTQvjhQLnnWrDzVpwtDDwVDnczwMwM
+vggZLZTldlhpCTlZlZCRRPNRmqdmGBHPFqsGqN
+wwFDFLMDjjCNgNwNlwwgvR
+frPbSJMSSPBqrfppSqrBZqMQhHlmNsRZmmslvghsmhsgggtZ
+TPSPfBQrdJSfTTqSbbBfTfdcGWjFWWFDWnGMjLjGVFCj
+LZRZbHtqnVztHTTTjMBQjQHH
+rJcDGpwwgDwCCWFGSFMSffVWfF
+cNNNgvhNglDnhdzsbLbmVs
+RwmrGVPmNLzdmVpmrVtHDjjgDHHRqjFtngFt
+CBlWhQWlTWshsblFGntjHtGbHG
+WsTSGZSTQZZJpPNdzSrzwvpr
+CVsggSgdwSwghVSTCgVZjJlRvlQNJHJGZVvjvj
+qrrnzrrpDFMzbDbbzrMbBcNjRBHHQHGRRllHHPBNBljl
+rnFppcpWcqnWMLDNsggSmWmsWfggdg
+wjQzPjJcplwmDDBL
+vghWhhnfWqzhftWtfnbFBmnGDnLGDbDmmC
+zZNvZrNsWfgVftNZhQcSdPHPTcPHQQTTJV
+WjvPVbWnbbFvjfLlcplQvLQvCwCl
+sJhmrrTRTDDJHhhsmJhmrNDdQwLQQlHllHwwLpCLclBBlcPC
+RJTRDdmPmmzNTDhnWtzMfMWtqjqqWM
+vvpjqtllDMlHDtDBsPSSfBJFlSffNS
+gwTmJrTcJWrNSmsNBBPfmf
+VzzJzgTnddzWrwngnWqbHqbtLqjqvpvqhbMd
+TlpzwGZGGFmZJdPpRtpHPrpcPs
+CMJCMgQjMQvrfMHtMfHv
+DjnNjCBqCCNnWWgDBQQDnCZwFJwmwwTznmFVwFmzTJJm
+CcDPppDCFdDrFcFsMsdlLVjjLsMHvM
+fqSmmtNGqLNffhHHbsMsbjbjNjbv
+SthSGmLnmfwfWGWhSQGSQRnGpDpJPCDJrBPTcPrDwPzFcpFT
+FdqjDtPWzqPdnPPtPFbssllqLJlqNppsJGppLp
+TwfrcvwRgvfTBWRgBssJhspHfffJHlHNGh
+MMZCQrrRBwQCCZMQwcTMwPztnFZSDWVWPttPSZzdzd
+prHlrpJbdccllrrPbFdrgPzZfZhZVhRZVScNRNWtSZjWRW
+LmwCCnvqwGCLMnsWtGRZWVfbfbftRW
+bwnvBnLBvbsBvszHzpgBlPzHHlzg
+grSJNTSgBHgpqhvCGbbZddGCGbbT
+nDLMssQMRLwMtMWRWCZdQfqjfGvZQfCjCc
+PqsDWPMLnwlRllJzghmgmSNhpgrl
+TQGcWQBDnSzzsBSL
+mJJlqJwVJdbSrhlrlhhsLL
+JPtwMtdPbJbVqVNpPtmbpwZcQDFFcCccFjCQjpQWSWZg
+JfbfpZJmzffmpZnZZwsrwDFvwHPP
+RDdQtWTWQQSTGNRhsFsjnvjwrhPjtH
+QccddTVQQldcGGRdGlgmVmBzfVpDmbgggmpL
+HVnhVcHvpVFWDpmP
+QswNZblTTwmqlntDPdqD
+sGZzNwsGNThhMrhBBhzn
+fQllBlVQncgwLlfWwWDvppZZggZqGpZgpGdvGG
+shPTRsFbNFJmvqpGjrpvPDdr
+RNFDtRRRssRTStRmTlnzwSVQlVVWfWzcQc
+WmCpPCWTjQPCWWSjSTmrqRLGDRFGrTFDRFDLDD
+gJnVcnVzdfnZgchvrslMDZGlRRDZLR
+fdHhfncwfbfzJbnJzJfcczhhSmLCCNBjSpjmpjHjBQjpmpNW
+BDvDPGRwRvCmLssGLmsL
+frRjjlldrqtNspLWpqFcCmzm
+ndSnVNtllldrdfSjfNvgVRHBwbbVMRbVPJgH
+PpgjhpVLghPZhSgZVVzzcJWccPNCrcJzrFsJ
+BdBNNMqMdfDnDNTFHHJCqHrJHzrFzF
+wfMNtMndlBTlmTBndRpgghhjZRjvSZVjRw
+ZQnQMWMcjHDHrWNF
+TvtCvvBVgdRdmvBVNzDHlGFjFHjfRfDD
+dvtCCbdJmhvhhhhbhVBPMwqZswnZqZjjMccsZJ
+DDMzRBBSzRDTMQRZsbvssCbhZtCDtP
+dLmwNplnmmwjGvPVCRtVVvVd
+NNmjLmqWJjFRwFSrgcrSHBzcTz
+TwTwTMBWcWBJJBtTWHddCmfgzlCzClsvmfsM
+PPLDnNqPRLQNVnGNVsDQnNmzdhvdddlvdlqgqmdlrfvv
+SQQsjPPLGLbDSnGLLNnWTFZJHbcpFctHZpwJWB
+FzMltgtMzFpZtmzdjPpnvRTQTvRWTDfnnTlvwW
+JcbVcBrqLCVJHJSNCcZVqVqqTRQRWWfNsTfTvDfsWvwTsnwv
+rcZqVJVhmhgPmhmd
+ttvSnlWvWWgcScMDsHHMPMjPmH
+pzLGLfNRpJsvmmfvMDfs
+GhpzRqqpZppNrhvFgwSlWnnBFn
+sbQcDJQJJDbQhwchSctVnVnqTMvMWSqTMPSMlP
+jtjCtNRLNCRgRnlTPPWg
+pzpHdLtFNdJbDhJHsQhs
+pSqnfqDnWPHNPCCHCp
+GdJZQdgZbBvgQLcCZZCCZlPLRH
+PzBgQggbvBthtMdMvbzvVfFfzTWqDmWDqzqWrfff
+nnJdrfgfrdMCMdgrqMnWdgwNTTTzFhPSSHfSHhllzjzNFT
+vBRvmvGZsLZZsHFNFFzTNPzb
+LZVRmcDRvpQLmvvVGDGmpntJJwCWCnCPJwgJDrPDqM
+QddMvdzlVfvdSQmGhmwLbGbmzbns
+JtCCWqqZDsLpGhbGjD
+FNrhqCTWMSRSrQQg
+ZsBZJFsZSmmJsJSmrJrJrvsrdGdCQGQphMGwRMGQRGdbBChM
+FlgfqNNNWnNnHfVnnHdbGwpwGWQhGdRMMdRM
+LFnggHlDqDLvjDmZPcPmvP
+CRHJWfvJvrQfrCsDlGGBszQBjjGB
+LmPHVnMmpLlPssBPlDtd
+MmMSZmVnncMFcmSVHvfSrffCwSvfbHWv
+wsrJrpdJLsMCZDWL
+BbLtGGbNmLQggqgQQtGgMmDCTnWZCZWZTmMmCZnT
+qNBGNNgQcbbtGbbFBLVjfcfwHvrHHJHJcr
+pCZCpdjBljhjBlpVccCpbDDwRWDsLhLbwDsDwsDw
+HNgFSSNvSmdqwsFLFWLGttbw
+gMMndNrzNHnzJZVlMCMCTcpc
+CfsFNszCrrGzrsggsPfPVNVlqTdSjSqMTdSVTdLL
+vRhcHllwJDmnJmDMMdhqSqpVMhdjdp
+cvHRvwQBPZZlrQgz
+TsFhCtQtQsBBLtBLPvgz
+jjWZZjZSMNlNNjljNnlmjjfJLMBGGLvBdzPQpggJJLQzpg
+wjbcmmlnQZmlrTsCFVwshwTr
+nRGFnFjcdlwLSHSpNNnBfWHN
+TgQvPbCMPRhbMPQvtQPvMCRBSHNQHBrQSNfWqpHHrWNWSf
+PCgMbPvTZVDgtPRggtCCbgmmFJJLmcGFLjdmJFcDwJmm
+dgWPssfdvQCLPLhL
+pMtSMtpSmpMpFSMMFZjQCLbLQZZbVbVhNTLblZ
+mpqcpzncfWwhzfRf
+vntvVnRCsvpBpMjCpTpj
+rQdZfhzczNzWcNLTpWgSvjjjpGpMSB
+ZqNDQhfcNchLchQqcDqRHJtHVwnwbtvHsbVs
+qtJGQgTrqtqQdQDgbGjPzZHWWzVjslPZlG
+vBShwRRvvSRSvFvwLSvfcnfBWmHZHVWWHPzlNPWVWjZsWnWV
+cLBFBFhCBLlwpFccFBFftqJDQdgdTDJJCbJgCCdg
+wfmsPvPwNfvmfLNFvzzJbRMnllhlnLhRLC
+gjtqDDTtjgpJcbnMTzCRnCCWhC
+SDqtpGSStVtdqpgBVjBGZmFPJNJmffvfPsHZPZQd
+HQMBBWrQQmPBvmBWnvrTnMSsbFfcfwgfCgscsmGgwgcJGg
+NzzlJLthtlgswGFcwGst
+JqNNRqpzhVRWTSQrrvSQ
+mFpDZjvmtPPGvFjmmGTzTcFRbHczHTbzQgRS
+fNdqhJsNrnnVNhwNVdrdsVczQCcwCMHSTCHgHCRzHgcM
+JlgnNhsqVqNqNpPlvZvDDDGlZZ

2022/day3/rust/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "rust_2022_03"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

2022/day3/rust/src/main.rs

@@ -0,0 +1,96 @@
+use std::{
+    io::{stdin, Read},
+    ops::{BitAnd, BitOr},
+};
+
+fn item_priority(item: char) -> u32 {
+    match item {
+        'a'..='z' => item as u32 - 'a' as u32 + 1,
+        'A'..='Z' => item as u32 - 'A' as u32 + 27,
+        _ => panic!("invalid item {item}"),
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct ItemSet(u64);
+
+impl ItemSet {
+    pub fn priority_of_single_item(self) -> Option<u32> {
+        if self.0.is_power_of_two() {
+            Some(self.0.trailing_zeros())
+        } else {
+            None
+        }
+    }
+}
+
+impl FromIterator<char> for ItemSet {
+    fn from_iter<T: IntoIterator<Item = char>>(iter: T) -> Self {
+        Self(
+            iter.into_iter()
+                .map(item_priority)
+                .fold(0, |acc, i| acc | (1 << i)),
+        )
+    }
+}
+
+impl BitOr for ItemSet {
+    type Output = Self;
+
+    fn bitor(self, rhs: Self) -> Self::Output {
+        Self(BitOr::bitor(self.0, rhs.0))
+    }
+}
+
+impl BitAnd for ItemSet {
+    type Output = Self;
+
+    fn bitand(self, rhs: Self) -> Self::Output {
+        Self(BitAnd::bitand(self.0, rhs.0))
+    }
+}
+
+struct Rucksack {
+    left: ItemSet,
+    right: ItemSet,
+}
+
+fn main() {
+    let mut data = String::new();
+    stdin().read_to_string(&mut data).unwrap();
+
+    let sacks: Vec<_> = data
+        .lines()
+        .map(|line| {
+            let (left, right) = line.split_at(line.len() / 2);
+            assert_eq!(left.len(), right.len());
+
+            let left = left.chars().collect();
+            let right = right.chars().collect();
+
+            Rucksack { left, right }
+        })
+        .collect();
+
+    let sum1: u32 = sacks
+        .iter()
+        .map(|sack| (sack.left & sack.right).priority_of_single_item().unwrap())
+        .sum();
+
+    let sum2: u32 = sacks
+        .chunks(3)
+        .into_iter()
+        .map(|sacks| {
+            sacks
+                .iter()
+                .map(|sack| sack.left | sack.right)
+                .reduce(BitAnd::bitand)
+                .unwrap()
+                .priority_of_single_item()
+                .unwrap()
+        })
+        .sum();
+
+    println!("{}", sum1);
+    println!("{}", sum2);
+}

Cargo.lock

@@ -469,6 +469,10 @@ version = "0.1.0"
 name = "rust_2022_02"
 version = "0.1.0"
 
+[[package]]
+name = "rust_2022_03"
+version = "0.1.0"
+
 [[package]]
 name = "ryu"
 version = "1.0.11"

Cargo.toml

@@ -11,4 +11,5 @@ members = [
 	"2021/day22/rust",
 	"2022/day1/rust",
 	"2022/day2/rust",
+	"2022/day3/rust",
 ]