From fff3de590a6f22ae430a0a5b95f3471e3e59f9f8 Mon Sep 17 00:00:00 2001 From: Sudhanshu Date: Sat, 3 Dec 2022 19:22:46 +0530 Subject: [PATCH 1/2] Solve part 1 --- 2022/rust/day-03/Cargo.toml | 8 + 2022/rust/day-03/input.txt | 300 +++++++++++++++++++++++++++++ 2022/rust/day-03/src/bin/part-1.rs | 7 + 2022/rust/day-03/src/lib.rs | 42 ++++ 4 files changed, 357 insertions(+) create mode 100644 2022/rust/day-03/Cargo.toml create mode 100644 2022/rust/day-03/input.txt create mode 100644 2022/rust/day-03/src/bin/part-1.rs create mode 100644 2022/rust/day-03/src/lib.rs diff --git a/2022/rust/day-03/Cargo.toml b/2022/rust/day-03/Cargo.toml new file mode 100644 index 0000000..51cc795 --- /dev/null +++ b/2022/rust/day-03/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "day-03" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/2022/rust/day-03/input.txt b/2022/rust/day-03/input.txt new file mode 100644 index 0000000..113848f --- /dev/null +++ b/2022/rust/day-03/input.txt @@ -0,0 +1,300 @@ +gtZDjBcmpcDgpZcmmbgtdtqmCGVCGGsvhCFCCqvmCMMM +JrhfzfLTNfJhPnhQnfzHfCFFQFSGvMFCGQFsQSMSVs +TllTRrfNNlfzwhtZBZgtRDBp +vMdwjZdjwjvjdTZZvCcQMGnQMQcbcgLLCL +rsVhfmssPWzDVGCLJSbCgPLSQG +lfWNDHDgfszFRTFtwwNjdv +GLPqVqdVGCLCdczjMjzMfzld +JnWQvJDmvWBtlMzhrzfHQgcz +tDtJDDDDtWRRmBwJwWtpPRsGCGScLPGSqspNCS +ChVzZzfNDzNJmBQfjjJfmH +MrTMPMncGMJvPPvPWTbrMWvgmBgQwgdpwmdpdpjwpHQcdw +SPvvvbqrFvMvZzJzsFVzVJNV +mvBbvMFqbMMVVmtCBHpDdDPTDspdNWPDVP +zjSfftcQtwtSfQSpNDppsNsjPNdRPP +fgfStJShrgvvCLLv +GmFnNNwbFFbhQQGQnGwwwfBgnMMqVDBZVVBMfMVzVz +vWzRRHzTHcgfZDVfBgfH +SSTvrvRcPpcvjFGwNGbNpbwQwz +FFgbZZFZgFmpstLgmbtzqNrwVPlMPlSWWrMPNp +QQhTvjhcvjjvTcTcTfCcSRwwWzwzPMrzWNNWVVhwrwWq +GRQBfCRnGGTcDvBfGvffCCjnFZtFFgStJLbLHbFLJZdgmd +pppdjcrMMRDJLJdRcwRDrwssqHGGDHsZHHsvBVtvmVHV +nlCFWzGzzQFlSlhGWnPzFbSsBZmsssmVVmsBvnHqvNVqqm +lFTTTCSQSTrdGJJLJG +jpsGMgsmghQwQsMmhlQshjtTNTRTnFqRWnnqRfFnnt +SLBCHrcvZHbSvSZrSvSWnfvVNvftVlFRTqnRTq +JrzdZbBcHBCrrlHrrSsMgmGpJPDPQmpgQgPG +cmcZHgwgMgHSLmtjLfWPNNrWBNfffp +JTqGTsClHslVVRVCVGVJGnBrjdnnrdBNvjPNBNBrWvnW +VVlQlqTFJlzzlsVGsRCZMthHDbwbFhgcbwHchg +qgZjgjjbssqgsjlNqjhTtdrfQdTdWLLnDVfHtHWd +zcGMBDDzcLnztfQQQz +JSppJcBScMmMFFBRCpRCMmGlggvjhbhlNlglwbslCZjhDZ +hvhmqcqwwcTBvvwQnRQnRnTRFzFzQz +jWLPPtPsgMtpdLMLWllpgLLQFQhFJjnVrzFrVFhnRzJJrJ +WPWffgtSdspdhSMdlSdtfBbHmSvqbNBCCmcBmcvcCH +frVcrVcggfSZJfbbJvBd +hwWQnwhWQmQmThTSsdvvSMBTBzcb +wGnFFCGlQwntGtCtwntwDmFwRgLrHqNRqqcNNgRrHHLggCjp +wRSwwHDMsRGHvNBNjTgvjgJD +mcLcFCclWQWQpPQWVQcQcvvNJjrNBTrvgJgBvTRvCg +VFPbQLchQLSRfbMtdHGH +lfVrhnlRRqrJZVDJdHSWCvJCJSbj +BFsgcgMNNQgSvbfCff +ffNPcMtzqPlnmRGh +ZJplFmRJmWRJRWmTJCvtTtnLCtndCqtqnr +SQsVPQHBQZNSNSLCfSLrcLcrrr +VMjPjbNMDsVHmRllmZpZWmjh +LcTLRbJhhdhLJbbclfVvfWQVWFRWFFfq +rZNttSNvtgsPPFsqBFPWQF +HGCSmHrrwNnHGMLpDhbzzpmJJv +VlSWzRtWSJqWdfhdqBdF +mTDHsmmmcHpgrCgCrTsMMtqfsFNsZqfdMZMNbd +TDcpvrpHCprCpHrmcQvTHgTQzSnLJnPPJlLzwJtRVJwLjJ +vZSWZJZJFvhZldZHdvvlphZSNGNnmzwCPNHNHGNrrRHGCPmP +bjfgcbjTQTFQBnGRRBCBNwBnCz +csqscsbssQLsgQcLgLQLQTQpFdlhdvdZdpZWhJplShWWtq +QgQvHnfflfBwQCfwlfglnQQccNcRqGGcjmcsGjddwdzsJc +DhZbTLZTDMVTsRzsqsRjszTz +FSZVtMLMMWbSgqSvPQlnpH +MMPllnnBmfSHvBgCLf +whZjGRJdjcNjjhRjCvgCfbSvCZLHfpZs +RRWGWwNRWwhwclmrgFmngFPMWm +VVHQGDGDGsdRrmZBQZRCVHZCNcSTTPMwwvTTwSSNqBqvgMvN +nfhdLfjFnJpblLbJjWhtnjWPScNnwSTPTPqTvgngNNvSvS +fpWljtpLjflfLfzlhZGQHZQVddHrrQRDRz +VCHCjwCwMSZSqQzhhQqcWZJD +GGGrFFgNRNNgmfnTdgmWQpczvPvQPWQJGDpzzc +lgTttRTgmfNRntrTTngrCbjCwJCHjLBBHlMVMsbB +szgPPlCblggVszhLmzvcvNrqpjNqmrqqpGvG +wBQDtBfQDtFvLjjctLqTMr +ZFWWdDLQFwSfDSBSQQBWnnnQVdbhgRVbsHzsshbClzzCVggb +VpVsHVcqcMVMMNHpsspstbMqzBztJZTBBfJfzTvZfvWJWSTv +mDDQgCQQQHdrwgSvZSmJJZvWfJJf +drCjggDlPdgrlbjNcnhcHsbpsj +cNNDRRpDcNcTpppsqHLQGLfRLvHzLH +lFntJjtbFFlsmsjvnGqHWLfhfqzzQh +sgPbjBJtPgbPJblblJgbgbwdBTwDCwpwrdZZVcCcDppc +GGclMjLnnjCMchcChLMLcnnzRFJDZJSRSzzzzDSShszPRS +VHgFQgwVwfNNpQVfHzQsPPPJDbmZbJDJbS +HfNVWdHVvgHgVWVNppNWVHwTlvBFcClBCjcTLTlBnnLrTL +GTLdlJhffQwDRvWLrp +HVZVNjjsPqzNjNNmNgDWMrRQpWvWRHrDHBWp +VCqVzjPjCpVqCVPCsbctcnblcGlTbGnlbFJf +flHdfdBNdZcflBMjqMjBNfZQhvJbGvqvsshJQsJCJDWvvD +gFTzRRpzRTwbgbLmtCvsJhWsChrWCrtWCC +VzzzFbVRLPznmRBffPNBHNMdlZfl +FFFMwCqJFFmrRwgnbLrL +GpjGpQHQpfjdjDRnLrbrRQmJzzgg +BphfhDcNcHNvPBvSqJMWJS +NndbWpDBNbjvWLZqWsWQ +JPFFTSPfgcMgftQQGjvTmsGqzssG +gPgcfcVFgcHqSqVhbBCHlpbbpDlhDD +FSdfWFTTBnjsDCjsmrrT +pQzLRVLppLGcQjqbmVDJsChCvCbVsm +qHLRGqqZzGjLqBNMFdnHlNlBFN +DjqbfBTchDjqqCjjCTWNTbdzSVzGZQGBwZnQnVwpSSnQ +ssJlPrtvMsRLrrJQGNZJSpZpGzSG +rlFssHsvPRPMvFmtHvtqjhTgjbqhWqNmNqgDNh +vcpnRqwwLLbvvcGpDQWDFSCgMrWWQWRR +gtNfBfllrFlHrlrl +ZPzftBmsNBNBPJBZPmZPNtmPdGLsqbwqpqcndVLLGpVGvqgV +vRBfQqqBQPfbrFvPBvPbhLDVDVDQZVVtZtlWLLLt +jcJmFFwnhJVZLWVl +sHTcmNNHzncmcjmdsBCrBCPCrBBqCFrqzb +bbZRnGmNnBGGMNRTgCmWWGGSrvSvFHvzFvFQDF +LjwphpdPdLpLJVqfJrQzDzfrvQHSvDcQrQ +DJphdwDsnmbZsTZM +rdNrZNBSzSztnNzWCcNpHlMwlwHWlM +QqLGLJvLjtvQWhgHgchHwHJw +GtjTGtDRqvfLRGnrzsmZmfrVFBrV +TdMhZrTTNvwphcLL +WnnmffmDWnWPsPCJNpNcpNVNQp +fsjbWfFFfnmmDsFDnnflSSdczlMdTHTzTTRRBdtT +cMcPcMcwgWJMjWWhFWCCQCmqCFdh +bSLVLblnNnLbVfnsbSbCChSQdChptpdqZrmCmZ +DLGNfnGVDNDHbfzjRcRgqHMRBJPc +HVFVlVHjzjjlCJjHjCjnvDrggrgLdqzddMqrzz +SSfBTmtNdLqngvrm +TwnNfPWWpBSBNtTHZCGlPHCQJHZHPV +prvccpFQpMcQBwsvssshdwSTPD +qbGHVbNJGqwdPgDrTsDJ +fGbGqqlGGHflqLlzZBBrRcrtrZlp +fCSPhltMBmPmbdgd +DjvJJscvTsHHDbWzBWsWbdwgLB +VVHDZvTppRcJVFFppvvRJDJqMSGqCtZdthttrnthSZMGCr +ZcSrSdrhDjBDDCmZdZmZjhwVHwqVVsMwgswVVwMfhw +PNvzTPNbnzcPbGQNJTvqwsWgVgVMMWpQqwgHpp +JTPGPTzNttnbRTPlPtNNRlFrFmBcmDljjmBFSCmLZZBr +mNvRRCVMtNRdFNtMtBHHprpHgJgJWwpBnprg +LZDDlSLlTslDfbcpJJWndwcscnwr +qdZZGSDhMVRCGtmC +VGFjjgBShGdGzQczcGRG +MppqCDfCMwfLDfvNmrtWstRcMPzRMRsRsPQS +NwDCffLppbqqrqvTBngSbnBHglZllH +vdllJVDzmVDVqvvWvdqJlcWrCsfCsfSSsSJfCSfQQCCbCQ +jnTHZPZHMjZhMjTpHgMpgnbNqBstnfrtSSrBSNssCrfN +LHLTFLjTMTTTwjHhpHTcwmDcWVDlvRDmvqwWlW +rqQsSStdmsdLqlNNPGlGlV +FpFpzJNTcHzRHRHlGwFVLFBLFGVvlw +WCCjWRNJTJWhQhbhrbnd +jsQjfrRTRwzSsRTgNchlnlhqcnlQmQ +dFDtdFBDddHLJpVpHHtVbtHFCWlWlGlNlmGggNqgglmcchqb +dLDHMVdLtBBDBFVJBFthtJHRTvsMSvsTrTSRvPPjPzSwRP +CSPpSrLlrlPrPchLnSlbDbbRttDVhbGRDDJRtD +fzfvmzTMmfsFszsHZsHMHVfwtbjBDDGjtRBjQQGGJb +HmvmTFmqmTsHqzzzzdTsMMScndccdLppnLCSPcCLrVgr +pfMflRnfrnjrpjnFzDpfDMmMLRTLZVTgLsvdZgLLZHSVWZRd +tBGNhwPGcNBBWwZddsSTTPgVLPdT +JwthtwbbhNBQhwhbBCrzpnprnWnprlzWlClD +PPnZZjnFNDjlJJhtMddfTTdD +QGLHFWvQJtzfpvCt +swqSmmQWLQwFWLwwRcqNNBnnbgPqbPNbglVZ +GCLSjjZGZhpvGtBgjJlnJDhhJMVDPnJlJP +mNtQQwNzQRHWdJHnPTsddlln +zQrfmbtNbcQcrzmrRBZqBcvpjSGLZGLZBB +zGNzgsjDssvNbPlWJfJq +RLMVSRMLhCLZSMZHDSJWvpcqfbfhvpJqcWPv +dMVHLFHLZMLRLLFRHHHVZMgDTntgstGwznzGGnzjDFwG +wCLCHLBwzBtQRLHLbNFFfdqdDqVrVfBN +JGvljmgGZvMlfDRRnnnZnfND +GppRlgJlSllSgjMsmllpTjcCLczWztPWPwwwzWThtcQh +WvHbvvWnFHszDRSltcCctCFD +gCmJmCCPTPqpgrZtjdRtDRplcSjS +rJJrQPPJQmrmrhGTznCfLMMbfvWfbCWQ +TqBWtTbFBNNRRtwQpJJvvvZPpTSQ +fRMfsMssrGhSmMwSQvvZJm +VggcVlsCgHnVFnndbbnR +NdrSSWBNPPSWWHPPlwlLZHLZLMhjlLLH +pVptMTgVTzLwZTzlbF +qsRmRJtsMvMqgqgRvCdcSrWSPcWrDmmdBN +nbJnfqWcmCMnSBSHwzWBsHHz +dVpdvdppdptppDlvlHcczSgNcgww +VGTdTVtGtRLFPTDbcfCmmcCQJQjcrT +VTjrjrjTlTjQMdpGrWMSHvSG +wnNJbDmttnwnhNwcJmNGdvWvMSfvMfhSSppSdp +JznFnNsGnzzGFDJsFNmLgVVQZBlLZjQTLTjTls +hpngHwcpWHgjjfhzTJBfBB +RFFbFlQlSdRsbRQQMGPRGdSGjBvvNTvzZMBvjzBBTJTvMBBT +GPSSPDDDFzGlGGRzLzGGPRWqnprcgCHwCHpwHWVcncLV +LLlLGffQLPRThRwP +MpZjbmznWqmqZznmzmpZqZnMRgPBCTPfgRTTwTjhwBPPghjP +VnZpMsMMJnWsmnJpJmzrtFlGQFrHGvSvfHStNV +MQqHMQPnqmpDdTLLRnDjsj +NGFzwgtLBtFFGrrCtzgfgCNgSsdTDSSTsdssjDdSlZRjTSBs +zCwNLthfrbCgzzhqhmccJPhQHVmV +SndBVcgdqcRBRcdPBBcVcQTSSMLMlTssMNMWsHMsLQ +GmJvZvhqpvZtNwwWLTTLwMMm +JFJpzFGZqjvhGZcjBPcCBBPnnVBc +rJWbqTvwvJNbPDPPvLcZvPDp +QMnfBsjmFPLcHRDfPp +lQlMlmtFsMMBstljlnGhtMhmGNqJqTcWNNbWdGwdNNJCrTrq +LcjcNCQNQWDpRDjRTj +vWvszVVSsBGWsTJRFHRJTTSTRJ +vvGbtqbGVVBqtzbqvBdzVLWNLClwnwMLWlQNMfdPQP +TWBZsWrjzZzWBrBsrrsTLNNJvFnJVmlSFFQnGpmnSJJS +qdCggdqqqhhqwhRbCwbCPqhlJFPPGJQVvvvnpVVmPnnFvS +ffgCfghDqDdCsGWZjTsLrsfW +QzQSSQmzSsLQcLmrcsLzccgqCnwqCtZDnDnrZwgnqTTT +hFRHHRPRPMtWPGVPRlMljRPCgWBBDTgJBgnwqTZDBZDWDB +jPjPHRMjjvdjVFhdNfbsbbQfbcddmNtL +jJlTqMqJtdztJqzcSJSlTdSlprLsRRHwcRRrsrHbrnnRHsHL +VVVMWNNWmNmLnPLRHrLp +NGhfvvVWBNfNNCNCQTMqjzgTQBSSSqll +SSSRMRSRpnMRHLqWLfPlDGlGWldD +hbNtlmvrNrsVDWsGPfPfqG +jvbBNmvlJjRcCzHFppCJ +hhWWPjnBGBGnjqBWSnhhsNLllLNcLczJcqcTlLTlfl +FHvFFMHwdmvrDbwCbbvHwdHnZTMLzTNTczflJTZclzNLlLcJ +HdFFvdDvpCDdrnwrGhBQhWRRpsjQWWQW +sBsvtJtdRdjNbWWrTllqlNgg +nSZSnPPZzMSnSlScWWWgrVWCrqgrWMWr +lzSncQcLZLzlwDvtdDdFdFJJhHvJ +lpsTLDlTtFtlWHPDvvgPfgMrQQJM +zmNbzcNjzldjwmbdbhhjcjRgfwrgvMwMMSRJSvQQvrRf +ZhjqcjzNhmzNqBqNznmcWHplCFGnpCtFsGWHHWsH +ZPGQBFHFbhSrHqtfSrSr +nMdznzzMDTnjMQrMWtrMptplqpqS +wzjczJmccTJCmcVghZBJbPBQBbVh +wLLMJbqSBBnnJhbvbFSSRRlztTrHzrrrrd +QNNGVPjWPGVqltTHWCqCdH +sjNGmmGVGgQNGDVmsVpgqQVpMDhvbLwMffZfhZbLnfLLLZwb +gQLcQrMtBPdwSBsSlmBm +TfCpTJnTbfqgsgwgppsSzp +jVbvTnvWfJnJjjbfCjWWjrFPrLMtcDPgLMQQRtgZVF +gwpHvpgwngGHcnvNvgnmsqCzmMzlfqmmqzHHCm +JrdSLdBVPRDtRtPfPPzCJhjqmljzmmqszzsM +SWLDDtVdrZWtSBRZfRcwgFGnpNFpnTnWnTvT +rpcnHrwrhWccNZDDBBgBVCSW +nmzFRRjFmmJQNDJC +qznMlqGnzRtRGvqGFRPrdMhwTpTLfLcppLHp +wthvbmhmChWMRJLJzngZpzLLNC +SsdBVjSTjBdffBFfcSdVHfTrnDZGpQgNZHNnLZGpJngJGLng +sSdTcdVScdcrccjcrBPrBSjcvmRRwlWPhwmqtgWhMPtmMMqR +CJJBdBCrHdBhtRHctBQhRMrBwZpwZWNZNSNTwSNpQWpZsSSW +LVFnvnbDjLsDPsPqFFvPvDnTzSTwNwPZpSmpSpgmgZWNTW +LjlflbFjsvVlrHcrHtrfcChH +tVLJGNRtfBBNGBrfrbzmfhPsrsPC +DWWDQHQgllSFqFzcsJmzzSSzmrrs +MJFQDgMqnHlDvFdGNBNNZGNVVvjV +wnNwGCBBFNWBqjFBnLLGVDHhHmDPHvZTjTvTrPvD +bMbttVScMJQtdgSgstbJRSPmrTHmHmrmmSDZlrPrPDhv +cMbgpsbVbzbdRMRFWLqzBfLGwwwwfW +JpSnGSGpbGgsWWPHJrdfsT +MNsRqNNvMQDTLWHlffNHLN +qqmtRzRvCRRQDqjqjDmsmRpZwSZbcwbnCcCSBBnSSnnC +TWqlqpRqRptqlRhrmtGGzhbSrSdz +VgsBVMvgVZfZvPsMVNvfZfvVbSPdhFPFhbzLhJdGFJmLhhhL +QZgvZgvHwbwHbMsMRllRjDRDnQRqlRjl +fsPQwnHnHLLfnBBnwwGtjTGRWTWTWwhV +jblbdjZFDMbGllqTGTtVlq +gmdMgZMbjpZDcrrDgdmszsPLpQfpBPPnNQNLLz +HRsPPGMhLPMrnPchPSwStjbSttSvtHSqQw +dfsCfpCJVJCvdFBFwStwjj +gTNWmWfTNVZVJzZWpWJgTpfhnDrMnDclgDlDrDRnRcMLDs +ZQZQJMqdwmZvqfPmwRjpBBjHjnshnjtt +zcTPTLDTFWLGTrTSWPcDSSHjRlhRsDhHslslssBRljjj +TrNFLbTWrGNZvmvVQPQV +htfLgmtSLcTWNLcT +slbHlBBGbqRsblBHvdNJJcjFFNBTVWWWcn +bbQsHMMblHrMsGRqvQhwCTQCwtQCzSpfmS +zmqdphmFmSpTzhdqhFmwjjGbtcvDbcGGjllGQjSP +HJFrMCsVLrHRRMCNrVMVnctvstlGcQlPtGGjQtGlvP +RFLHLVWrNgVJzwzwfgffwdfp +vdMjSmMMpmMWhRpndRmZnhvHqLpGHcJGGGDLHHLGcfcLfc +lPBwwrsCgLFggcqqLW +TWszsWNBTNdmSRvjbZZT +zFlBGpzzzLLNjBwPcwwmcNPfWNQn +VHSHRJTJDSVVnmcVVPpWmpnf +DMZHHrDHHrJrrZrShZsHGbMBbFgGjGCgjpFlBzzb +FVMpsvTqvqMssVsWZSrqWFvwlGDGwQzwfwQQNLzDlwlZwf +hPbgBHhJJcJPwCwDpNllCCHC +pnjbBmjgbgmqtSmsTtsF +DHZHmfTmCfjDZHMZmzffHHnQwwTBdQwbSdBGBQwhBQTQww +cqstRFWNtLrNFwdVShlBSlhBRl +StJWpLptNWLtJcpqPrFHDjZzzvnDDHPCZjPvvz +hzffhGVGGhzRqTBLTqHL +sFFFsMQlwJMsmrBFSNHTHNqrTS +pbdsJMdJMJbwbmJJtbTtgnffGgVVChvD +FvJnFnCpQTddSSmFdFpPPsVhppDjBzjDVhDV +RgZMZbsgzlDPlhjb +cHHHRgRZgfHHZGZfHZcLLHrrCrmJCmddrsvdJsmvFFQG +dpJDdZwLnvdvFmFMmHjslMLH +CGCztgPhWCWhzzzNNPGfrrWfmbbsmmHjFHDMsbHMsjFPjbHm +rNQDGzzhCCfNrzrDzChTcZZvQcTRJpTwdvQpVc +VpvNGhGHGNhHbPsbVbvfFtLCzSCFSBsCFSFCLB +MlqJwTnrRRrRnMlQMHfHzHzWFWtmTzLWFC +ljZDDHqqjqRbpNhjNNgcgc +qrQtDzcQzbrcfdbqrQrthtscSsvpvnsSHpTpLpspmsSs +CVwNNVRNBSHsLSFBTv +CVVVNZjlVlGwlGlljNlWJVrrfqbPQQqHqJhhftbfDJqf +lpmrPDPDjPlmWrVzPztZwFjtFbBnRtZbbcRL +dnqJCCgQdNqbqRbRbBLt +QGhGddGCTdMHNTGgshgJhzvSmWWPSsnprpPzWzsWlr +hCJHTdJJNvTdSSNssjvfwgntwDgtgwDGCtZwtRRB +mbllFmFMFbMVWWLpbpZwwBZTZnnVwnTggtDB +MmzLQpFPTmPzHvfJNNzhNs +dzgBwzlgrrBrVLLlwLBgBlgRScDMMDDswMsHZRGDsZGZmM +HPfPbjCFJjCvfnnsjsDDcccmZsRSMc +hCvHfWPPnvJhPWpqNNhqLqzLqLLd \ No newline at end of file diff --git a/2022/rust/day-03/src/bin/part-1.rs b/2022/rust/day-03/src/bin/part-1.rs new file mode 100644 index 0000000..aa9cfe9 --- /dev/null +++ b/2022/rust/day-03/src/bin/part-1.rs @@ -0,0 +1,7 @@ +use day_03::process_part1; +use std::fs; + +fn main() { + let file = fs::read_to_string("./input.txt").unwrap(); + println!("{}", process_part1(&file)); +} diff --git a/2022/rust/day-03/src/lib.rs b/2022/rust/day-03/src/lib.rs new file mode 100644 index 0000000..d77fef4 --- /dev/null +++ b/2022/rust/day-03/src/lib.rs @@ -0,0 +1,42 @@ +use std::collections::HashMap; + +pub fn process_part1(input: &str) -> usize { + let letter_scores = ('a'..='z') + .chain('A'..='Z') + .enumerate() + .map(|(idx, c)| (c, idx + 1)) + .collect::>(); + + let result = input + .lines() + .map(|rucksack| { + let len = rucksack.len() / 2; + let compartment_1 = &rucksack[..len]; + let compartment_2 = &rucksack[len..]; + + let common_item = compartment_1 + .chars() + .find(|c| compartment_2.contains(*c)) + .unwrap(); + letter_scores.get(&common_item).unwrap() + }) + .sum::(); + result +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn part1_works() { + const INPUT: &str = "vJrwpWtwJgWrhcsFMMfFFhFp +jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL +PmmdzqPrVvPwwTWBwg +wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn +ttgJtRGJQctTZtZT +CrZsJsPPZsGzwwsLwLmpwMDw"; + let result = process_part1(&INPUT); + assert_eq!(result, 157); + } +} From 7ab4a2ac351b465bbdd1fc629413671d6be3c7df Mon Sep 17 00:00:00 2001 From: Sudhanshu Date: Sat, 3 Dec 2022 19:54:40 +0530 Subject: [PATCH 2/2] Solve part 2 after enabling nightly feature --- 2022/rust/day-03/src/bin/part-2.rs | 7 ++++++ 2022/rust/day-03/src/lib.rs | 37 ++++++++++++++++++++++++++++++ 2 files changed, 44 insertions(+) create mode 100644 2022/rust/day-03/src/bin/part-2.rs diff --git a/2022/rust/day-03/src/bin/part-2.rs b/2022/rust/day-03/src/bin/part-2.rs new file mode 100644 index 0000000..dcd4074 --- /dev/null +++ b/2022/rust/day-03/src/bin/part-2.rs @@ -0,0 +1,7 @@ +use day_03::process_part2; +use std::fs; + +fn main() { + let file = fs::read_to_string("./input.txt").unwrap(); + println!("{}", process_part2(&file)); +} diff --git a/2022/rust/day-03/src/lib.rs b/2022/rust/day-03/src/lib.rs index d77fef4..913df30 100644 --- a/2022/rust/day-03/src/lib.rs +++ b/2022/rust/day-03/src/lib.rs @@ -1,3 +1,5 @@ +#![feature(iter_array_chunks)] + use std::collections::HashMap; pub fn process_part1(input: &str) -> usize { @@ -24,6 +26,29 @@ pub fn process_part1(input: &str) -> usize { result } +pub fn process_part2(input: &str) -> usize { + let letter_scores = ('a'..='z') + .chain('A'..='Z') + .enumerate() + .map(|(idx, c)| (c, idx + 1)) + .collect::>(); + + let result = input + .lines() + .array_chunks::<3>() + .map(|[a, b, c]| { + let common_item = a + .chars() + .find(|a_char| b.contains(*a_char) && c.contains(*a_char)) + .unwrap(); + + letter_scores.get(&common_item).unwrap() + }) + .sum::(); + + result +} + #[cfg(test)] mod tests { use super::*; @@ -39,4 +64,16 @@ CrZsJsPPZsGzwwsLwLmpwMDw"; let result = process_part1(&INPUT); assert_eq!(result, 157); } + + #[test] + fn part2_works() { + const INPUT: &str = "vJrwpWtwJgWrhcsFMMfFFhFp +jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL +PmmdzqPrVvPwwTWBwg +wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn +ttgJtRGJQctTZtZT +CrZsJsPPZsGzwwsLwLmpwMDw"; + let result = process_part2(&INPUT); + assert_eq!(result, 70); + } }