Replace collecting then computing by reduce.

This is a bad idea; it's actually slower

2022/Cargo.toml

@@ -8,7 +8,6 @@ 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 = 4;
+const DAYS_IMPLEMENTED: u8 = 2;
 
 fn read_input(day: u8) -> Vec<u8> {
     let input_path = format!("inputs/{:02}.txt", day);

2022/inputs/03.txt

@@ -1,300 +0,0 @@
-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,15 +92,3 @@ 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,6 +2,7 @@ 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;
@@ -13,9 +14,13 @@ 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 elves = parse_input(input, parse_elf_list)?;
+    let result = parse_input(input, parse_max)?.to_string();
-    Ok(elves.into_iter().fold(0, Ord::max).to_string())
+    Ok(result)
 }
 
 fn parse_elf_list(input: &[u8]) -> IResult<&[u8], Vec<i32>> {

2022/src/day02.rs

@@ -1,12 +1,15 @@
+use std::ops::Add;
+
 use anyhow::Result;
 use nom::character::complete::newline;
+use nom::combinator::map;
 use nom::combinator::map_res;
-use nom::multi::many0;
 use nom::sequence::separated_pair;
 use nom::sequence::terminated;
 use nom::IResult;
 
 use crate::common::parse_input;
+use crate::common::reduce_many1;
 
 #[derive(Copy, Clone, Eq, PartialEq)]
 enum Rps {
@@ -70,7 +73,7 @@ impl TryFrom<u8> for Rps {
     }
 }
 
-fn parse_plan(input: &[u8]) -> IResult<&[u8], Vec<(Rps, Rps)>> {
+fn parse_line(input: &[u8]) -> IResult<&[u8], (Rps, Rps)> {
     fn parse_rps(input: &[u8]) -> IResult<&[u8], Rps> {
         // Note: alpha1 also sort of works but is significantly slower
         map_res(nom::bytes::complete::take(1usize), |v: &[u8]| {
@@ -78,33 +81,34 @@ fn parse_plan(input: &[u8]) -> IResult<&[u8], Vec<(Rps, Rps)>> {
         })(input)
     }
 
-    fn parse_line(input: &[u8]) -> IResult<&[u8], (Rps, Rps)> {
+    terminated(
-        separated_pair(parse_rps, nom::character::complete::char(' '), parse_rps)(input)
+        separated_pair(parse_rps, nom::character::complete::char(' '), parse_rps),
-    }
+        newline,
-
+    )(input)
-    many0(terminated(parse_line, newline))(input)
 }
 
 pub fn part1(input: &[u8]) -> Result<String> {
-    let plan = parse_input(input, parse_plan)?;
+    parse_input(
-
+        input,
-    let result: u32 = plan
+        reduce_many1(
-        .into_iter()
+            map(parse_line, |(them, us)| us.score() + us.score_against(them)),
-        .map(|(them, us)| us.score() + us.score_against(them))
+            Add::add,
-        .sum();
+        ),
-
+    )
-    Ok(result.to_string())
+    .map(|sum| sum.to_string())
 }
 
 pub fn part2(input: &[u8]) -> Result<String> {
-    let plan = parse_input(input, parse_plan)?;
+    parse_input(
-
+        input,
-    let result: u32 = plan
+        reduce_many1(
-        .into_iter()
+            map(parse_line, |(them, us)| {
-        .map(|(them, us)| us.score_result() + us.needed(them).score())
+                us.score_result() + us.needed(them).score()
-        .sum();
+            }),
-
+            Add::add,
-    Ok(result.to_string())
+        ),
+    )
+    .map(|sum| sum.to_string())
 }
 
 #[cfg(test)]

2022/src/day03.rs

@@ -1,79 +1,9 @@
 use anyhow::Result;
-use itertools::Itertools;
 
-fn priority(item: u8) -> u32 {
+pub fn part1(_input: &[u8]) -> Result<String> {
-    match item {
+    todo!()
-        b'a'..=b'z' => item - b'a' + 1,
-        b'A'..=b'Z' => item - b'A' + 27,
-        _ => 0,
-    }
-    .into()
 }
 
-fn seen(backpack: &[u8]) -> u64 {
+pub fn part2(_input: &[u8]) -> Result<String> {
-    let mut seen = 0;
+    todo!()
-
-    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,75 +1,9 @@
-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;
 
-use crate::common::parse_input;
+pub fn part1(_input: &[u8]) -> Result<String> {
-
+    todo!()
-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)
-    }
-
-    let parse_line = separated_pair(parse_single, tag(","), parse_single);
-
-    many0(terminated(parse_line, newline))(input)
 }
 
-fn is_contained(a: &Assignment, b: &Assignment) -> bool {
+pub fn part2(_input: &[u8]) -> Result<String> {
-    if a.size_hint().0 > b.size_hint().0 {
+    todo!()
-        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

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

2022/src/samples/04.txt

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