Reimplement day 4 2022 with ranges instead of ints

2022/Cargo.toml

@@ -8,6 +8,7 @@ edition = "2021"
 [dependencies]
 anyhow = "1.0.66"
 clap = { version = "4.0.19", features = ["derive"] }
+itertools = "0.10.5"
 nom = "7.1.1"
 
 [dev-dependencies]

2022/benches/days.rs

@@ -8,7 +8,7 @@ use criterion::BenchmarkId;
 use criterion::Criterion;
 
 /// Number of days we have an implementation to benchmark
-const DAYS_IMPLEMENTED: u8 = 2;
+const DAYS_IMPLEMENTED: u8 = 4;
 
 fn read_input(day: u8) -> Vec<u8> {
     let input_path = format!("inputs/{:02}.txt", day);

2022/inputs/03.txt

@@ -0,0 +1,300 @@
+NJvhJcQWTJWTNTFFMTqqGqfTmB
+VwVzPldRZVLVRmfsvfjvqfmm
+ZDPDHZHVcvDhbvnv
+FHHwHBzzVCWWmmCzCPrVmgBwbLTtRFFbbbttRGRLjTcLpbbT
+vhZZvdsNSdSMdNvjncppCLcLnGnj
+CDZZsNZMZqdNSdlNZCqrzPHDzgrgzwVVWwmwwm
+ndlndntsFJntFvccLjjLrjBShcBBfc
+GpCGHzVwmmzqQWSSSfWHBhQL
+mpCMGGCZVzVwGGVwmJsZnFtZnTSTJtdsvl
+nCnPDGmDNmVCsVQDmGSWqvzchWSjjcWGqS
+gTnBRLpfTRnrTdZgdLfRdrThvqcvWWhFFWvcFSSgjqqzjv
+pfZfTMwrbLTTfsbmQtlVtHHnbs
+wNdSdsbTvTZMTvTv
+rrdRWdWQhFVdHWBGWQmmmnnMvCfmnhvmCmtZ
+rJrVDRWpGddpbSlNSlspPP
+chTNrthMMwWMTjfsmRzZszJpwm
+BLnFFCngbcBnbbldDlpRjGpmsCzGsGsRGmmG
+dqvnvlgbqtcPPMhH
+QcLNqZbCzJDQBJJRpwzRpdnRldgnpf
+GmmmvVGsHrWffrlwdCWd
+CMsFVVFjCmFStGQbbLZNBbJBcTjc
+LQVggbQvcLbQLHgvVLhWGGsChssrMWfzGccc
+qDnRTTRqJttPfWMChJhGslWlzh
+qRTRwPBTBtRZdnjnqqqnQVbjbNLFbbfLgVmgHLQm
+cZbzwCwZPlJcMLrNSNfHWNBBNZ
+vsQsDCqtsDhmtjVrBNWNjBHrhr
+TtDTGnvTlgbbRCGg
+BgBlplHlsgNNsJlVpBtPwJhMPRRQSSttRtSP
+bvhTnmdFTzddStwStQRddt
+ZnZDLvnvqZzbbhFzzmTbnFsVjVlNgsCCNVsVLpNWVgsB
+TdptqrrcVGhhzFtw
+DRnSfwJlDmmDDVGv
+RCSQNSCQZndwbcMqQrBB
+wvRlrlwVwwqzgbZRdCJBWfmdzCWfBdhf
+cFcsQpNtLLsGTtNGpMdPmDdPBmmBvJPWvDtC
+TpjssTFFvLLLcFFQpwbwwHngjHRrZRqZVH
+mqqddrPPcPmqPDlrQnjTrbvMvbHzzsjjpTvz
+gtBWgGgVhLGWHzMDztzstDHj
+hfWRhBBNBGgLNQDPwdNPcPdw
+LhQzdhhbTzpMhddhhhTzhnZcBFllHZFtrrHZHMHFjlHr
+mwwssqDvjptrvplr
+NCSgVDPDwmDgVJVpLfTznQJdhfLhnhQQ
+GzjzDhjhhZzcrRgQCBjBPBBjQCgT
+vHHHmntsbSgLwbsSmNHbwNbvpqPCBVppCpFTpTPTBtqWBCqV
+NJbwNSwdndvmvwhGhgzcfMcDJfgJ
+GncgDvvcMGnttjDvrgRRFSZZLZFWdJFJwGQwZBWZ
+bPqpChPfsshfZZBdZdLTFZ
+lNqqsClmbsNlPbHqPsmblmsrHdvdMngcVrjggvrvggRDcn
+bDvtgVVVpMQvjQWmQL
+rwTflmlfZJBBdQWQWjQqdM
+HsJJmZZwscHrwTrcRbzpcbPgtCSbgz
+CsCsRvshMjpbqCqf
+ncblgDBgtDmmmTlBgwlgbHHqMFHLqPDMHPHHpqWfFM
+TcBctSmTZTtSTzsZvsvJZRsGVb
+znznvngttwltzlLwhtThHbqHPvNbNHSSHmmNWHjP
+FBcLrRMFQpPqpPSpqHHW
+fRQMJZJfrcMcMVrQJJftnwCzVCltgTnstTVnVL
+MfLlRfCMrLzRlQgwNqQFcsGd
+jtTjjBTvbdqcGjqFcj
+vvShDSBDppzhCmzq
+plWMptTvfrnncvcRfwqzqLGhzhzThNzNNJqD
+jSdSHFPQQbdPCQCssjSbBmhJGNZZNGNqqJNBlJqqLh
+VCCCVCQgjdddjCgljCjbbwgRRttgrpftfWrgvpwpnf
+MWlbBcPjjvvjPWWMPqgRQZfJZDGGbRZJffQQwh
+HrHrnncHpzrJQJfVDQVR
+zzsSTtSTLzsspSdtTmHHmpmtFgqcgPlgFqWBqqqBMdWWvFlg
+nSqBbJbqlnBBClVZcMgZVgcP
+FQwrwHrRwWWFBRPNgNgcCGZZZC
+rWFWFTwpwwWzHrnDbfJDLDbBBbbz
+BMmNtLMMtFCNFNMvvLmcndpgcdgppPrgrGPPrgJD
+WVWWhbTtVnGpjrrPhr
+HWssSTHWfRHRsQQFLvfvFFCLCNMNlt
+sTmDsQffVrrLCjTFltTFWL
+BnwwQBJbJndMMRzMwCLlWlLWWCWLLtRlWF
+cqqBMcMqwnznMGzcvDmQhrvssHmPDVssrP
+pQGQGJDDrDVJbbfVzvvgPcCZwhZhncscZWWc
+SqMMlBBljMmRlchhPTqThCZnPs
+FMjMBmjRNFHQJJpHVhVDhG
+tHNNdBdNtBBBMgsMpsZm
+wVPzVvbwqzhrVqvjqzzsZpDsZDsZmsCPCgZgCM
+bVbvLThvvbrWqHmmnJLdHdJQLn
+PzTspPZpdLLDZTplPLpPDpvbfhnqNvqzfvNMzQQfNwnQ
+GWRHmjmFWMMSnhbhHw
+JWWcmtBrBtWBFWGJpsgTgldhLVLpJl
+DwLMDzLMhvMcwvgdVqWWlCVgvlqF
+TTSBBRpbStHZVgjWFldjRVlV
+SnbTBdJBmnpQzMPDMcMznr
+nNlMNBPPNtJQnbZhZsgSbh
+czzCjcwTdvSbgQNcgNQq
+VTdNdGDTzDTdlFFPtBrtLtDr
+FMbbfMlzvFsmgVZmmg
+SrNTHGmdSQDqLhtQhhgggs
+dRDTSDPPcHRdHGDHlwJBbmwljmMcfjbW
+sQgWLtqLtWhdqlpNZRpG
+blTHTjlvTCJnJvRZdGGhHHGZhFGV
+CCDlJclnCmbrmBMgcwcLWtcBsB
+vqPWWvqwwCFvFZfZPRFRrcGQrQwsDrNcrwnbDNcQ
+LVgJLSBBVtzTLzBMmTMJmLnnDNQcrsGbsQbNbrbDjs
+zggVSmmhVdfqFhvHWG
+WwdndGGmmmLwwwmRwWSncLRnZqZqhqZthBtqtBqZBgtdtvMH
+FfHHzlQQDsFzzrNsVTfttZvTvttTqqtbqb
+lQjFDNQFPjCsVCCDjGCwwSGGnccwcHppGp
+mrjggcFsFMjdjZRpSZpn
+NCqfLCFNbQPzPPlPzNfSRTRZdSdWWwndpqRSSd
+vDvzzbPQFNCFtllLLNMBhMcDHGBGMggMmcBc
+jhjlBvvnjbtDNPjtSjBDBbDNgHggrQrhghRQrqRrZcRwwqVg
+pLdTMsWdLLmpMdqZZdPdVqZgHPwH
+WLTCGmMLfPSlbGjlnnJD
+gtbwhgHbHgqqbgQthgQLtZZCRjMcjjnRnrRNJmMRJrNhRc
+bGWVTTvDvfpVFFBpvvVTdRDMJcrccCrJnMRnNnNCcc
+FVWTBsdvdTzTBFWssVQtLgSQtHqqPzPbqHbw
+dlzrPTSSjSrllzWhsvVmVtTRTWtf
+bJMpLGcqGhNbJQttVQmmvRWWsp
+qLbMwqqbGHFGzrlZrjhPHCrj
+rNrrffVlqqrfLlPpltcBBTTGRzzZRPRsBTcJ
+msbsmWSsMmQwjdMbWMhMhQmcRZRzGjTBGTBcBJBjCHJGcC
+FwWbvdhbmrsFrfrgsN
+rHjrQHdhdQrvSddcHWLssBSVVpBSWWWWWf
+JNfTGtqDwVWBMBMpwM
+qlltZgfJFvcRgcRjvc
+CqfcwfDqwwmRnnqmRdNRBTRTRrdGdNpTvF
+WVbzsZszBbrsvpdMpdQM
+tJhbVZHWLLHDgnSwnSSgHB
+TZCqqlTsqpZVVsZQJSBSLpLmppnJzmFz
+brSgNtGjjRjRRjDddDtrRJcJJbJmmwcmBmnPcJFwFB
+jgdRtMjNNjfqlMvShvSZSZ
+dJTdqCwMNCgqTQllGBdlGBmmmZ
+fcVfVcnbVfrwDLWVfncZBQPlBHRGljLZQjHGQl
+brwnnfSFDvfzCTqFzgMJTh
+njnsPBjjsrrnGLnbTTjGvcldQPCMllNzMvRQPCdd
+ggZgfZtmZVpqZqZWDgFmgqfCcQRcRcWhQcccQddMcvRQdQ
+tfqgggVgHpDwDtfwbGLJRjbLjsrLTj
+JmrfrmTlDWTfgQCdHCdpqBvQdD
+jsZtVzNsSNVQQHnBlVQR
+PljljFjPljSsLPtFLTTgTcFrrfMJmrrmrr
+hmGcmmndhmGnfmtGnDzFLwrFJQsQFzNFrNJG
+ZSqPlSWcWlbgqWVTVWRVZPrjQqjzjFNJzLsNJsLJNqNL
+RHcWTZbSMMMPgZcWgSWPPbVMDnBffmtdpDBddfnnvmCdfC
+vSJvsbFfJfvqCsTHJswssJnLTZjjhzrrzLrzLMrzhdjM
+pBNQDPcpmWDcBNgMMnZPVjdddnndhH
+QWlDgmpmgDBlGRgDDgffSqwSwGCwHfvqwSFJ
+jvlgvMJclPdGdtdcjMVmMHbFHFVHWHbZHZ
+CwhLzLhzQpnqfpfqDVHCHbsbDFZDmHmj
+LnBzfQjSzQrPvJvdSSrr
+wpcvcsqclDCnVCVvWfnZ
+BLRMRtbnbbBLNCjNCjVVZhbC
+rFgMPSRnrRpmqpJwqFDs
+LZQNQbMrZppLNLQplvlGLNvVmmmfjbwVCfjbwJwCmBCwfj
+ShTPRFtTHZPCsnwswsFwCF
+WtHRPdThSqZTRtDqtdRWTdpGDLLzrNczvzMGLlQLGDDM
+hdcffBvldjhCMljqPwWwWNwWdwqHZr
+LtQmbQRVsZQZMZPQSN
+tmMRsJMpDhjJzJhv
+wNQCMFCDQDBmrHmmRWrrHN
+SShLnfqpcqpSZSfrzJvRVrvfrrJH
+cRpqdGclpScltTQQtsFQMQsTCT
+NCjggZmgfBgnBmgWbcwcTFctcWWfvb
+HsDGthRGrtppSQpbFFJTVcJdFbTRvd
+rPDGhDDrSzZLtzBLZMCB
+RsBBMBsCBlFFCgRsBJzlMjMPNSdPhSrSrzLbmSDrDNmDSd
+pZHZZJpGHHHpTTHvTncZqVLdqLbhLrDLdhrSLLbLDDdD
+tGtwnJccvCtCffMBgt
+wbddvVjfwPhbjjbDbbvbjvTNCNmfHZfpCZRJNzCmJmnJNC
+BslcLtclZWsZJWNrRRNRpRmR
+BSLBlScGtFMcssMBBFGLlQZTDZQjPddVwwbTdvvdhTZb
+NSZHzmLZBnzHmLLzLSntDttDDtddhDtttDWW
+QgfjsrrvNNJwtMddcvcvtq
+jrfgfQpQrTTVLSNBClFV
+GQWcWWPPQRcrJQNDdRcDmmLCFSnqNSmqhCNvFnql
+zHfwjzpMjwZmCLqvvnlljC
+ZgtVZBtHHZtgQGgPrbPRJdPv
+TWdWpJTJTdgLWfWLlLFLrfrgBGsNqhGslBGHqSNqqBNshnws
+ZpQmjzbZZCjZCCCPZtttRCCwsBnHNssBHbShsshHqsGBqN
+RDRRPpPCzmZCtRpVVJFrfTfWFLLJggJrDv
+pDDFlglsvFMgntlTMMqNffmTdfddRM
+jhGJLVCHQpHGQCCzLjWdTTdZZdNdcRWNccWfNN
+jQjSGjrjCQLhzVSLSCSHGDpngbrnDFtFBwBglBnBvg
+wsLzstsgszcpcGLHGpcgcghlDBvQvjQvbFbQCbJBtCCJJv
+mnSqRSSqSRThWRnmWWRSJDFTFCFCblbBCFQFCjFj
+rZRRWqSSdZZfMVnZLspPsMgHpzMhHGPg
+mwHrCLSWWwrsHCHDDsVrsmhfFZFnSSBlFlgZbbgBglbggj
+GJdpcRtGJvNRdcPtdpJJdbQZfjfQBlnQBjnBtbfFnB
+qcPpqqzFzJqvPVCCmWrVwhrWrz
+jjMbvbhDvnRjNRGMmjbMZftSSwwwthJSffStctcwqd
+lTQrVlpCVvCcfdcSJqLVcw
+srHFWCHrFlrHlrsBsprljjRmDZZnmbDngNBgbNZv
+MgTlQJlTQJZWpgLrRssrVqqqpRts
+bBNbbzSSjMBPjzhMjsPtRVVRVPRqLttGGs
+SjHBbfjNCDfjZgTlZdMJnDJW
+lpThgTwtplhghgwhThqnnrdZctSZSjSZcRSRfbdrrc
+RBVBGvmBmfdrcvrbbr
+PmVGNGmmGRLLQwwLqTnglQ
+nHwnBwBTnFHQwRsMhwghmzcm
+GtprdCpdtqWdbqbrfdnPPszsWmRzRnShPszS
+dGptbCfCrlnVDBJNLDLLVDLQ
+CZtCjhTndCzqbCNq
+dwpGvpsmwGslDszrNNrzqDMzWMgJ
+vmcGccvpBVPTVTjTdTTTdZ
+jWZhvZLjZfCZDwrDrSSzJGhVdJccscGsgV
+blMBlRqqqgSJLBLcsJ
+blmHLmFMMMnRqLmMMFqHmfPDfjQDnCDDQrZvfCjvDr
+rnvnHrDLFZmMFLvrHQBMGQggBztzglplRl
+sbWWhdNzsshsfhcsjJJPPbWdtQGVGllRTRjRRgBgQlpRlppB
+PPCCwNWhPhNfWCzbqmFnDFFnCDLSrvZS
+GChNjwWlWJWTJZBggvdgnQgdhdnd
+HPsHfHHrpHDpFFrcSfsfpCMmQdntLBMgtmtBgDdLLC
+SqpPscpPzpSWzjlCjjCGjl
+nvgLvcLgvgvngbLprpJNTDCCRNVJrNPlDDTV
+WZsMtsffGQtMzWFqFmWmWsVNJNlDwwCDVRTwJlCCDVLz
+BQfGZGmmsMWFstWFmfMsfBccdncbpbSbvbbvHnLbpc
+tsmDsvswNZmcZTccfh
+zCTpGCbWBRWFWHGRFZJbMbJfnrhnhfMnnZ
+TzFGFBRLdpHHNNQddDQDvwQN
+fhBBpJgdHddjZQfmVmNzNNLmFN
+qvMRrvlbwqlbTTMBMvLssFNmVzzwFDmLLzVD
+TRSRWqRRMcBHhGHcdGgPGp
+lSjHmtmnpHStblnpSlHSrtmMzLWzqzqCZDDTzTTWqMFqCqVV
+sLRLLfPPRQfCTqqVVqFT
+dNJgRPNQNsJJhBRvdJvQvNNsjSrrSmrcctpbpHtBrBjLjmSH
+nwFwpppjfwSlpLTsqsTgNshhjM
+ccBRGvtsmgGNPqNNGP
+BCcJHvssdcWBCVmVHSSrZrwVzblpwbzZnf
+rcfQRrBPPczjcRBctZDNlnVNHbgZGjVDjN
+TvMsFJGSFMhJnNZlwVVnDNTZ
+qhSqqmqLCLhFdJLqSvLhmQRQRWcRPczPtzrCrWGRBp
+JVhdPhsFPFqLDBHVdHLPvhHDCMwcgJJwbwRgnnCMbwGwcmGC
+fzjzpTZTQQQLwCbgGgbMmQcR
+jzNpTzfSZtfNSWZlVVtdFFFDHHqLHVqv
+TwSNnSnSGVTpNppGlPTlTcVqQrRhVBqdqBRqZqQZqQ
+DcDCMfDbCMHJdrRBqbdjRBRZ
+gvftMCJHcHfCDmDLgfMmMmmWlwWnWsTTwlGTlWTwppNlGL
+pbGMbllDQPhhWWQDpPgVGlMCvRRrQLcCCcfBBQzLBcvQBv
+wqnJjSmjrstdqwwFBLcRsBRRszzLFC
+qwdddTJTdHtjndqJqHZHmwVWGpDbGTlbWWpWWrPGhhhM
+WGllqLjjLCpSffmBmvfpHs
+dnrQwZzRTdZwnCThdzzFTVmcBHBJBmsHfBPHcfvcSVHs
+QgQrzCdrTRCZzrZLbjGLqNMWGgNNLt
+sgPnhPPTTPTTwlJfwNHlqcfs
+LMCpFbLLbRpMGbMcCFLVlNlNqrHqVfbHHwNDwr
+GjBcCCtWMtMRZTSvgWQTngvg
+BCMtJJMpRDlMMvBJBBnfjtcjPhPmZgnhgdcf
+NrsrsqFNvrVLVGVrsHsqFgfmcPGdcmhfjdPgfjcnZd
+zFTzsNqHqFssLVLQqNTFbsBDwCCwvWlDwRMRCTRBDMDS
+zQtLgvggSRtgvVRtLvvnzdnjnGwGdmmrlpnlGz
+JssBFpqsDqPNnlWWjrrjqrnj
+DHDFBNDfPbJBsFHNMPvpvStQvMRVTtgVTVtv
+FvzttFvBTJJzLbvwhCnnVnWwjCnBNC
+mQdZgZPDPdPPSsMSQPdZgCwVGmnwnWpGnGhqNWjWCG
+ggdDgfQSdcjtFHjlLJfF
+ghcgScNNSsCvGSzmpVFlZbrzcFcV
+MWWRLRqqqdQwTtLjjmqMlFpFlzVnbFVDwplFzlDr
+LHMHqdHWjdQMdMtLHHLtWjJRsGCGSNghmSvPBJBNhsGfvfGP
+CbVqqqDbcbMHnnDqcCbrRFCfBvvwGjzrBwQGzrwwBjGwBQ
+sTPmpNWdWPTJssSSLPfNljjBvflGtjwwBzMG
+mmWgmgSZLTLMZWpnhqZbhFFCnhqnnn
+QQmjmZqnmQrfTZlbbcVbBcfbHfzf
+vpdSNShNppFdSRtdGBqvJBDlDzqbPPHVBH
+tRNSNRFhNpSRhFRMFtGhRGswLZZsZqWnmrmZwqwsTZmmmQ
+gGWCllFCGWtGGWdlGlWNZdwpnnSbwpMvpphZpndn
+RsshDDLcQVMSJQwJwnvw
+HVPzrPcDNhPFGhPC
+jtHQGHjGGtdTLjnqTQlmvRPRPBBwRBnFPPWP
+hZbzNzVrczZzcbNssVspZZVvBwbmPmJPWmvbBRvPlmvRJF
+fzNVDsZMhzpVhpVhlZcMNfcDDdQTLTjGDTCqGCjtSQHdHL
+GrbFggGrTrzSrgfwJjdTmwmNJZJd
+VMPQplPDptchwdsjmlml
+MqMWtBDPPWDWHQtvqQtWPjbzCGLgSBgGbzgrzFgnnz
+fcJccCcwcDfcpbRnCfWJnQJqtqtqPQdsGdgPsgTQqg
+LSjVMhzSFFrljdNbltNGtgdqQq
+MMhSHFFMLzBWDcHHcfcHwb
+rwmWtJWMwSNRJMtwNmMrrSsmtTjjlgqnTqZZZPlHnTngTTgn
+BGqGqqFBFggjjdGHlj
+QDhhLbDQCDFMNcmhRhqJNW
+BnRnRvMnLGLSCHvvSnlRfWbbTNQJsJsbNbJTBfQT
+tzMmmMwjhcpFjDmMcptrcjzFQggfQPTsWsfgNbbgfhJbPhQT
+FdzcrtDwDMtcwtFGRZdRLvdnHRSZZv
+HVpsSpvjpNjsBmbGFBnMNnDM
+WRRWhZtfrVtLJrBZMnDmDbnZBTGF
+thhPLzWzhzwPtLRLWrQlpPvvClcVcCppSvpl
+lZPbhnZLRPnnPZZPdlGMBWcBMgMQHBBcvvvzBL
+jpFjmwwwCDDbsjvjjgcvQgcNBQ
+rbFmppbwhqhGRGZr
+ggrLwFgWCBwbMWBbFwLMgNBZdmZHclJPllnJlNRPmSNZRR
+ppszzDfhDfhsqpnvDVTfGpSPlPmclHcdRcZmmmdPPGSP
+pvtDDVDVpqDfzDfngBLCwQrgCtCwFwrg
+pbGjFFGGDjpbsGsmNhNFNRBBBtRhhhHv
+JnczJVCvwWJvhPgghgNtNtNJ
+nwVSSzdzzqSpvQSZQG
+mssLLttQrsMrMzLCRmMmrrSQpvWpDNlBTBDlvNTccDQl
+HdHJwJqVPwHnqJwbjJbGjnSgSTWPpNgWWpgBBgcvDWWN
+ZHVwVZGwwdndqJVJqfHbGwnwrRLtLMftMvMMRrhmLMthhLmz
+RgHGLbTqlZlPRZPHfvvfZttJnvfvjnzr
+sVcChDVDccwNhhvjTvVzWJjnzFff
+mpNcCMTCGmLqBLGH
+wVJwHJHVMtMpBmDDWPQVPWDGDD
+zCrlZzCblBvnCDWNGLmvGDLPNG
+dqZglgbzrzbbgZqzTFSBHHFJSSSfjjSMfwhj
+NMWJSjLMCnHHNMNNHWCHMbVVGBPZTrPVPBVDrBSDGTTr
+zvttlFpgdtldwwvftPDPTWQdBZrsrWrGBZ
+hFlFmhRFvfCbmWJWHcnj

2022/src/common.rs

@@ -92,3 +92,15 @@ where
         }
     }
 }
+
+/// Return the minimum and maximum of two unordered variables
+pub fn minmax<T>(a: T, b: T) -> (T, T)
+where
+    T: PartialOrd,
+{
+    if a < b {
+        (a, b)
+    } else {
+        (b, a)
+    }
+}

2022/src/day01.rs

@@ -2,7 +2,6 @@ use std::ops::Add;
 
 use anyhow::Result;
 use nom::character::complete::newline;
-use nom::combinator::opt;
 use nom::multi::separated_list0;
 use nom::sequence::terminated;
 use nom::IResult;
@@ -14,13 +13,9 @@ fn parse_elf(input: &[u8]) -> IResult<&[u8], i32> {
     reduce_many1(terminated(nom::character::complete::i32, newline), Add::add)(input)
 }
 
-fn parse_max(input: &[u8]) -> IResult<&[u8], i32> {
-    reduce_many1(terminated(parse_elf, opt(newline)), Ord::max)(input)
-}
-
 pub fn part1(input: &[u8]) -> Result<String> {
-    let result = parse_input(input, parse_max)?.to_string();
-    Ok(result)
+    let elves = parse_input(input, parse_elf_list)?;
+    Ok(elves.into_iter().fold(0, Ord::max).to_string())
 }
 
 fn parse_elf_list(input: &[u8]) -> IResult<&[u8], Vec<i32>> {

2022/src/day03.rs

@@ -1,9 +1,79 @@
 use anyhow::Result;
+use itertools::Itertools;
 
-pub fn part1(_input: &[u8]) -> Result<String> {
-    todo!()
+fn priority(item: u8) -> u32 {
+    match item {
+        b'a'..=b'z' => item - b'a' + 1,
+        b'A'..=b'Z' => item - b'A' + 27,
+        _ => 0,
+    }
+    .into()
 }
 
-pub fn part2(_input: &[u8]) -> Result<String> {
-    todo!()
+fn seen(backpack: &[u8]) -> u64 {
+    let mut seen = 0;
+
+    for &b in backpack {
+        seen |= 1 << priority(b);
+    }
+
+    seen
+}
+
+pub fn part1(input: &[u8]) -> Result<String> {
+    let mut total = 0;
+
+    for line in input.split(|&b| b == b'\n') {
+        let (first, last) = line.split_at(line.len() / 2);
+
+        let seen = seen(first);
+
+        for &b in last {
+            let prio = priority(b);
+
+            if (seen & (1 << prio)) != 0 {
+                total += prio;
+                break;
+            }
+        }
+    }
+
+    Ok(total.to_string())
+}
+
+pub fn part2(input: &[u8]) -> Result<String> {
+    let mut total = 0;
+
+    for chunk in &input.split(|&b| b == b'\n').chunks(3) {
+        let mut mask = u64::MAX;
+
+        for backpack in chunk {
+            let seen = seen(backpack);
+            mask &= seen;
+        }
+
+        if mask != 0 {
+            debug_assert_eq!(1, mask.count_ones());
+            total += mask.trailing_zeros();
+        }
+    }
+
+    Ok(total.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const SAMPLE: &[u8] = include_bytes!("samples/03.txt");
+
+    #[test]
+    fn sample_part1() {
+        assert_eq!(part1(SAMPLE).unwrap(), "157")
+    }
+
+    #[test]
+    fn sample_part2() {
+        assert_eq!(part2(SAMPLE).unwrap(), "70")
+    }
 }

2022/src/day04.rs

@@ -1,9 +1,75 @@
+use std::ops::RangeInclusive;
+
 use anyhow::Result;
+use nom::bytes::complete::tag;
+use nom::character::complete::newline;
+use nom::combinator::map;
+use nom::multi::many0;
+use nom::sequence::separated_pair;
+use nom::sequence::terminated;
+use nom::IResult;
 
-pub fn part1(_input: &[u8]) -> Result<String> {
-    todo!()
+use crate::common::parse_input;
+
+type Assignment = RangeInclusive<u32>;
+
+fn parse_assignments(
+    input: &[u8],
+) -> IResult<&[u8], Vec<(RangeInclusive<u32>, RangeInclusive<u32>)>> {
+    use nom::character::complete::u32;
+
+    fn parse_single(input: &[u8]) -> IResult<&[u8], Assignment> {
+        map(separated_pair(u32, tag("-"), u32), |(start, end)| {
+            start..=end
+        })(input)
     }
 
-pub fn part2(_input: &[u8]) -> Result<String> {
-    todo!()
+    let parse_line = separated_pair(parse_single, tag(","), parse_single);
+
+    many0(terminated(parse_line, newline))(input)
+}
+
+fn is_contained(a: &Assignment, b: &Assignment) -> bool {
+    if a.size_hint().0 > b.size_hint().0 {
+        a.contains(b.start()) && a.contains(b.end())
+    } else {
+        b.contains(a.start()) && b.contains(a.end())
+    }
+}
+
+fn is_overlapping(a: &Assignment, b: &Assignment) -> bool {
+    b.end() >= a.start() && b.start() <= a.end() || a.end() >= b.start() && a.start() <= b.end()
+}
+
+fn parts_common(input: &[u8], filter: impl Fn(&Assignment, &Assignment) -> bool) -> Result<String> {
+    let assigments = parse_input(input, parse_assignments)?;
+
+    let overlapping = assigments.into_iter().filter(|(a, b)| filter(a, b)).count();
+
+    Ok(overlapping.to_string())
+}
+
+pub fn part1(input: &[u8]) -> Result<String> {
+    parts_common(input, is_contained)
+}
+
+pub fn part2(input: &[u8]) -> Result<String> {
+    parts_common(input, is_overlapping)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const SAMPLE: &[u8] = include_bytes!("samples/04.txt");
+
+    #[test]
+    fn sample_part1() {
+        assert_eq!(part1(SAMPLE).unwrap(), "2")
+    }
+
+    #[test]
+    fn sample_part2() {
+        assert_eq!(part2(SAMPLE).unwrap(), "4")
+    }
 }

2022/src/samples/03.txt

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

2022/src/samples/04.txt

@@ -0,0 +1,6 @@
+2-4,6-8
+2-3,4-5
+5-7,7-9
+2-8,3-7
+6-6,4-6
+2-6,4-8