From 27c116932406043898b9d81cd19177cf8f9c505b Mon Sep 17 00:00:00 2001 From: Gard Spreemann Date: Thu, 8 Dec 2022 09:57:53 +0100 Subject: Day 3 --- 03/Cargo.toml | 15 +++ 03/input.txt | 300 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 03/src/part-1.rs | 54 ++++++++++ 03/src/part-2.rs | 76 ++++++++++++++ 03/test.txt | 6 ++ 5 files changed, 451 insertions(+) create mode 100644 03/Cargo.toml create mode 100644 03/input.txt create mode 100644 03/src/part-1.rs create mode 100644 03/src/part-2.rs create mode 100644 03/test.txt diff --git a/03/Cargo.toml b/03/Cargo.toml new file mode 100644 index 0000000..5544c40 --- /dev/null +++ b/03/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "day-03" +version = "0.1.0" +authors = ["Gard Spreemann "] +edition = "2021" + +[[bin]] +name = "part-1" +path = "src/part-1.rs" + +[[bin]] +name = "part-2" +path = "src/part-2.rs" + +[dependencies] diff --git a/03/input.txt b/03/input.txt new file mode 100644 index 0000000..9b16a3c --- /dev/null +++ b/03/input.txt @@ -0,0 +1,300 @@ +WVHGHwddqSsNjsjwqVvdwZRCbcJcZTCcsZbLcJJsCZ +hngprFFhFDFhrDpzzQDhtnBJJRJZbZvTcvbfRCJfBRcBJl +DmptngtFwvvMmwmm +HFddrJnLdqtHBMQBmmVm +gbvNsbhsvQtmZTbQPT +vDshDlczcDhcssscwzQwslLJrSJLpqrrzpnCrSfLSnqq +pDGQDSpFDGzFDQSJqzDhjhQMTjTrwTstbTBTjTtLtbTMBT +zgzVNHHgMwMLbLNB +WRWPgdHCZccggJmJGzJmzGhGCD +sVJNlhldShpdpnnwVnwCwtwggt +WLFFcHWQLPPZQCgtnCgmbtbHwt +MPLWzRMMcGgRrWNDpSSSfDflMlTd +BBMZJcgBRjCZZzBpSvHQvbLvvHCQLQ +VlVTFwDTVGnfWSQPtsDPbvrpDS +wWdqhWlwGVfGwlfTVqFWfWWjzZZBJmMZMNdzZJMpjzNjgJ +FBWFphQBmDmpmMSpDWVcVcvsPcRbrjPMcMsr +HHtdnHnwNCHCTJRTPTzrbvVbcVRr +lHqHwlnlqnGCNGGmWDvvZfpZvG +mfVtmPtsccMmHcHCFfmhVmnpgZLbWPZqWnpqZbZWpgPW +zzvwBrzdQDvpZJfQJZJpLf +BrTBwRdNcfNmfStc +sTlhFLfZTTLcfsLlLDZflvQvRNqRJFNvRMRNvQQRBQ +CWcgwStWwCWWwvgNQvJBvQMQRB +wptGzbzGWVGSCVVlVlLDcVVsfhLTlf +HVnMVGwLLbsGnVsLnwLSBggMhjmgmgmhtmqhtgMhMj +zrZzJRZfzZfrPCrFcWccPdTdHHlvdmlgTghCtmtTgq +NFfcZWWzZrrHLBpBBGVGNG +HqFhhCBCBLmwwCqJCHFvvFdcprrrSSrjRFRjpgrggb +VGzWtQzGGQPVtlVNslVWsPdRpmcRrjpSzcrcbdSmSnSg +WPPGllQMPGmTLvLJBCwM +PvDWRSmTVvSvRhbZRpRpbjjjzM +GBFGHLglHrrrLgGrttbMjpbcpcZJBsBp +lrHgrrndgdNnlHGFQPMMmWPTvvWSCDQn +mmhQShhmhQfzNfTTlShbHJrRtltltJJtHlRLLZ +WscggNqwPWjcGcWWcpNcRJHHprZvZHrvtttZJpJr +jGjgcMGCwPNsGDCcszBfhhQQQDnFnTVVBV +mcGjrwzQcrZtQzZQDZcPssvPVVCPCVLwswwPBC +NJbqHddNSgdPWvvsVHVLPs +NqglNSlJFNSbSNdldNlNdNbTRFDrvRmQrQGtmDrvttQmmtDj +zzcBPnHBjgHjWJvbJQTvScbwcQ +qdspVCFqVqfFqLFCqtpTwtpTbSTbJpwBST +FRLFRCNNqMfdWNmZPBPZrHmm +VmtRRJmtrDrwhRcvPspltvgqtqsd +WGQBZzMMBGBGbZTTWWCMNSgggqnPlsfbqndndccglffg +CWQQZMFWdzMQdJJwJVFrwmmmRw +rZsFfGfNhznzsjhzZfVjGVvVdvSTSJHSDDtcmmmttC +wWpRBWlbWMWlQDvCcRSvJRSStm +LPlwWqbgwqjjcFshNf +lsppsGphmPrRQnvHdRpd +qBgjLqMjgjTLPnzHPrPRLnzv +gSMfNjNtttVbqBbtTSStjTqlhmlZDsDsbWZWFFFsGhlWPm +sPDPDzrGzBsGRsbwrjtSVvthVfQtQw +ClpgFZgNqMWCgqCpMNZqNWmNdtSwtljtVHQhtwfvdHtSdhSj +FpNCJpNcpfCpgNWPGBLcbTGTzTzPnG +mssNLCZqSqmNCHmrqHChJTjTjnRRnnqVnTTGngGTRn +dbwptFwQbvdtcvpZDcDddgzGPjTGgpPTRpzzzgRzTn +BwZdtZldDbrSsNrsrSHl +MLnFWMRWpnpnLnLCmPGTqQsFzBttTQ +SwNlDHNcddglSDBjrqmqGQqqmGtGGwszPP +vdSlNcrvvvnBMbBR +psZPRmTpRpgrlrDRBFgV +jvCqNhwnjhGNqCMqVgFHWtgHBrtwHFrJ +cGvbNcjvvhhjcvbQGcZdZSQpzdpmpPVpdZpd +drTHDdlHzllZDTzTQRQLsPPSsBbSjQdL +MfVVWmNvMnqNmVVpMMgfgMmvBFFfRRLQPPsPfsFLFCFRSFjR +whMnNVnqWmlllHswJTZT +ZSQTTLLlTsbmmDZlmNQSNFfPwHwqCjCCfjwFPwfwLr +MctMJMBVttnhJcBBVctwRHjHRJwJwjFfqPfRwj +vzqgqhBVzzTlZmmTlN +WgvlHJFvljvdBmzcvcwpmchc +TQqZsTZttLZbRZsLLMzzppBmNShCmBNTcNCN +LPMZsMZLMQVgglFPhFHlFl +qsBCPVPqVbwfnMQNmZJnqJgR +hHdrvvLWtvtjWQnZJTMrmpTZgN +DShSShLZdFGPGDPGsPsG +qRBddRzFFqFqHnNnPSnnmmSpgpJm +ssZDQMvvMwppNJWRDRpW +MMvwlsRMcQBjcLqLBBqc +ZGHpwFGvwpHrvfFTMtDfccMjntMntc +RgSCLRLJRSRSQQqJmTDMPMTtsJjnclBjtj +LVmmSSddLCwVHDbzDzZr +psgWdsBjnnJjbZWQDDLNrDcrLVQjLM +zPSCCHqCfqfmWNMcrVSLRM +TPHzWPFTGztqTGgdJdsssvZgwb +gcFgBChcClJjNCPb +sWZdZdrSmWmSZRwSmsvPlsTtTtNMnnlvnJJv +GSWrHZdGQpRrrSGmpWQmQfLfpVzDfghppzBVLBlBqg +BFNqFzBNhqVwmTtsqVst +dMwMwMfCMWbDtDvDssCC +ldMwMSHHMMWJpRpPLLpBzPZjgnZPhN +WczRJhcWggVBdzPPLnCjdvjm +lSpSTpTSsCCmmntNdp +wSFDCTwsGDqQqQVWWcJw +RqPqhDGBhRDrrhBFmPmbgssZbwbgCbwsmZsQ +nCtjMppjfTpjJJfVZwtzZtllLZwLss +MHfpMWdHpSCSfnSTJWhDDFDFBGqDGvvDBDFd +MCCGMCSHVGNTspVWQznddndg +rttLtvRbrhLZrbcQdJnnQdfddsrggf +BbRqltRtHsNNllNC +ncFpcsLLdFmWlRmnllTR +bMMVzVqMzjNVDblmRTPGlSmmPlqG +gNDDJMVZNCbNJNDNQCbZCbscvBsdBvrRHfcpdQpfFFff +VnWFbZvFbHWhFjZWVJZJLZFWTttpMCspQTTzQCHpgQMgztzT +dGcfdNdGrlRlBDGNSllfBMspgzmTgtQQgztMtzpmcT +lBNdqRsBRdfPNrLPFVVPVJPZZvhj +TLWgggJzwjgWgjgGnnmQnzQfNNNQsm +SpPbBlPBMlvFZpbbBmQGsmCJmCstsdNGBQ +MhSHhZPrPbvSFrJPpPMSbMcLjjqTLHDRTDDTTLDLTqgH +fprRRbbznFbcQVPDdQPdFV +LTvmsLmcsHmvDvSZDZVVSS +jWtmLccssJTLjHmLWWJwnwlBfwnBbllpCBnffbBr +plPBWzbnFLPPtGqMMwlMGwmS +ZQjDHjrQjdjVFwdMvCSfmwMqdt +DDhhrRDjQghHJjhWBbgbTccbsTzpWF +vgCbbwsTbWWWgwBWDGGDqtPGtMgGlFMH +znrznJNhLSLphRRRDlFPMmpFPjjHtMFF +llNcSQVSNcRbvCwwWcTdwZ +qpnJbnRRnJhRFhFHRgQSzHlSRHCCCg +fMBttBvsBjffvsQTtfGTWlCWsSgSmHCzZmLlHgzZ +ffMdjrfdwjfwwnhJPFchhqwQ +NCVSTCVCQCCRVDQSJsqFPsPNspFhhsgjPh +btvtWtcWnpgmFhjmmt +cfnffBfcWcrMdbvMQJDDrDTDVCpCDrGD +fZNhBWFSlFQFjWQTTldHgCwvTvqqdr +zznVzCznmHvnwgdH +PMMbCGPMDPcLbJhFhWhBhRScQZBQ +WQMrDWGHbSWHMNrTQRhghmgPZccmqDLwPqPg +svCzfpdzzdsnslCsnPZcHZPlJcqZgmqPPc +nntVpdpVsfjCHzvnsCzRTBrtWGbNNQSMbTNSRr +SnpDQdBqGpDSBMfQGcMQBDJPNstvJcWNsPJCtJtNRWPC +VrVHrhTHlPHTvvNtbhNRNswC +TzlFHHmrVlgTlTGSzGqpdMGBPQBS +zrCDnrDVCnCgnrHgGDnVVCZsNttQZmjtsmbMqGqsjbqj +TlRRWPSwwFwbSwTTTpNQQqNjqZZlmMMQQt +wvbwbRTLWdFFwvRBTbvTTRzrnznnJrDDCzBczBfHCJnz +SvTdmLNNNdvTBmvmLvSvDpgczzjfgjggpcjcNPzD +VJHQsJVlHpjjpzsjzP +VRlJbJQrVbVHJJPMhBdnBRCSLZZZnvnLvv +tMGcpGtMtLtsCGspLzNCBBmwCzQRzBBRWQ +hdlHFllDdZgDbDDlDHTWWTnzBBBvzmNHzwRz +FSddDlFRqDFqFSdPVqdhcfGMsVtVfLjrfGfjtMcs +RGMWnBMWfCCMBHTDptJJgZStRPmSRD +bqzFqjqcFLNLZZSmpSBgZZ +rFrQNbNBlNcbrQlNQvvclMswTCTCnwrwHrWGsGCswn +WLhJQddCQwRNCQNHczHNzMvZcZvcNc +SlSpSlrpDqnbqDjlGjGGljTjMZZPPMMfVPgfHMMVgVvqfgcw +SbGsDspbbnjTjBldCFmLwFCJLBmtJB +TMDjMvMqMvDTzcmFCgrJCr +ZZZJSZWVBHZWSSZQJhVhWnHJwczGGwGcCCFzwgmzcwFgwVzc +pLHNQSnNJsMLRJds +TsLZGwdsDFWHBZJFfZ +mqhRvqrzJRbmzJBFfgHHgWgHrrlH +JvvNhJmvtDdsNTwdLV +wwnSVSmwtbstznwgbzzVMTNpTNWdlCSlSWTffWNCSN +cFvccLGFGvvGHZflnNTpnZpZcB +GPqGDhGGqrDhVRgbnbttPmgs +rzSZJScLrcBLvjvsqMPZvjQl +nnpDqgDqFTgwqHHvMHvvvTvPMM +GnqCGpDqqVhccLmrmSmCRL +tJSTmdfddDTDJCPmbQvQLHvqqqbrbvlP +zWGsjcwwGGcVVjcGWcNjvNjQqrQtNFFQHHrF +RZnRVsswRsGWcwVBZVtBRdDJgCffTgmgfnnCpfTfTM +FnCrzhTrNPrMcnhMTnZZZNPwDPdbDmdDtwjdtjbmQwDt +sBvWrpppvLBsLRVBfHSfbbQmbwSjStDSwSwS +LVRRRJqqlHNlNTChrhMG +WNsfsstMvtMvNNGPZwmZmqZPLWZcww +rDCdDRCDFQjSVLcmZcDq +bBBHqTgBbQlQRCQFbgqdhvshGvTJMnfTtnnThnsN +VwWBTNQcVzDtrgfrtzzt +LLbpShLGvlbCmLjpGSCSCpvFdrgdddcHtrtGgfqHcDHqrd +pmvLmlpmjbLbpljJPBBcTBBQRZBBVJRZ +cVTcVTNvvghNhvggPPgtCVSpSQmzCqZDRCmDZDZS +dGJMWFsFMFWsnlzRlQzlzqpzlZzD +HdLFssFMsJbnbFjqbhPgjNggcrhg +LLVhQCTvRvmWlCppQfQQjPrwszNsfzNz +BZSgncHgnJStJHJgntMWzGsrPqGwsfPfGPwwwZ +bdBdJMBcShWCLbhWVC +vjdpGNGwSNCTwwRbfnWgQMLjQWMnLQ +DcmFPFtHmlcgpqWDnMbDLf +FZJPtcprHtPPHplZHPZclwwGBSZSvSwCwvZzNdwvvw +CdJLJCJPWPWcbtzJtqJzFrQvBhfjBBvjjvdjpFjr +sBRgsZGDNSBBRGDwphrrrThpHpgHvhpQ +DwDsGBDNwGmMNlMlMDSPmztJVCbVCCWqPqJLmW +LSTMgDSRSMHbMDWLHSvDScwtCGqGrjGrcLftqVGtVC +hzJPmlphCGrCwVrJ +zhPNdNnQZBZBhZnNZSgMWMDbMHwWSDWNDH +rcdvvcwvrHrMZBjHSZ +sDtWblgnltsDFlgFqltCCVQTMTgSHVTfSQfSHj +tDtRWFpFbWWWWNNDWsNqWvmzvhzhzGmzjjGvLwJmpc +nFSSnnbhSfgLSSnVjdjfHMgfMzGzmqlNGGmTPlqqTzTNNzlT +pBZsJJvccbBmlWGlNb +cvsssvZwsDwrDdfFgnbDfVbgng +mWRNWNCTdwdCwhCddbWWmhsZVgJQJBVBfsBsJQLQBLJb +qFFlGzFtjjcqzHtFtlRfVfsZfQHVfBHQRHgf +jqGjtcDnGnPzFRlzrnMdWrrCMMddNNWT +MHWCjjGMcHhbhPDLphHQ +nRVJrtgssdLgCppvLQbg +RlVVZNVRJlsstldsBCNlczfjjSZmWTcmGmTSfmSm +RTHqgTgMwgnGTRzqTHCGfdFdfhmBrJrdvbFJMhPB +lNZNNNLttLWJBPBdZBFmdZ +SppscpLVStclNPWtCczqnQQwHTTgCGwq +hSHRCbZRSZhbRZBctnMVjwwtWtwh +GrdFzQrDdJstjcWttwsF +drPJLDPGPvDvzrJPQLdDHpZlwLgRmwCHLpwgSbff +zMSSnCtCdSdCtdfMdHMdtVBDjhWDHBqbTVVBqhbDjr +cPNhFFNRlNDlTBqjlTBG +RvmvRpPNRgwgPvFwhmdCssmCzdMshMmL +tttjgrpTwmCgCwgwrrlrHzbzqqFNzdJqqZnddJwNbh +cQjMjPMBfcLBSjGQBndFnzNdNnhzzNGFbF +sSQPLMfVPBVSfBMvVLSPfHCttDjCDRRtrVVglgpttD +vdTvdpBvcTPdSSvCLrCCDLDCQGDl +sRfnFgmFRMVsnqgRmqzmrrDBDwtHlLHtrLCDGL +qRMVjJgRFnJfMssMsgZScPJpZbPbPPWhBZSp +ZJgNJhGZglMZZFDTPSNqFSqTSb +mwdvwpsjrcjBvpwFrvbHcDqbWHRWDSPWDHSR +CsvpsLLjFzhlLGFZ +sDNQrMrNfrlQjJRgGjbTllHG +ZRhSnWFVSwBtFRBVvVgHgbzjgGTJnngmGmHC +vWZLShhvZLVtSFSLqwVrQdqpcqMDddRNQMdsNP +hQhSQbbwtHzShwhSQPbJRsLwRCjJmDCcvmqCcs +FNdBTBTNMsRqqCjTjL +GNdrdMBVFShhSLSGGL +cZzcCmjjcvdzdWqgWTZgPZgZhh +wSwVGSJFTffgJTNh +FSVpVlBMShzbjzcpvp +qqlblClRbnTvqTmRqlmnTwrdfdwFFNrngfddDBrNtr +PcLcQLMVLGMzHLMchhLcjLFrrNrBfrfFNJtNgJDDBNzt +sSjjGcGQscSVSMjHVMSVPSQsWmCmppZCmtCWbbWTlZTqTl +qWlVJmDJHWJHVJlsdVTdhbFNNgFhwhhhFhwwZg +npjnvQpStCQLvBpPnvtBtBpGSGbzbGDggGNbgwghzZNGGN +jBvLtvjnrtMDmmDRTTrsWc +pmwdwzJtFmmlpFsWwtstJPGgvNgCCLWCvPgNNPQCQv +RfbfTRBnRGQvPNnncc +ZTbPZSDSBfSBVSbbBRbbbtrFdtlFmVsswtFwzdpszw +hVphQcmdcWWprWWhChFQBsfHjDTTBCHlSsTSBgSH +vqBRqqzbqMZPMwSTDjJjlHDllgHZ +PMnMLqtMnntQhWBccthB +vqqvCSvHSSwqvqCddnvQFmNbVjbJVVmGNNVHNNlH +pggrhzWgptWhZsmVlFmgNNVNbj +RzpMLLhhphtzrRrSSbQTBQwSTDBwQM +DSFQDlDFRddDHQHQtFlDVsVMTzrMCLSWZLZffSzLWrfCJz +jjBBvpgmbppBPbMwBBBNbbZWZzzCCTzzZgzWcJccLzWz +bvPwNwmpnBNhPmqpPvnwwNmtRQGQMdQDQlsGVVGhRlGFsl +SfJJwDJgpGdSGJNSTwTVJDRbWWfLtCWCLtRLHWrtbWBf +cQQPnFhjjQlczhqllhszhqsQRWnrbrHdHtbWrBWBbtvvHBrW +qMqqqqzFFmPjmmsFjmzsmhjcDGSZTJgTdpZwZgwSZVpMTNVG +czrcHMcMJtCCPnpFmH +DwGGlvLljGmDRdwLdLjfhtFsssnFVpfttpptsnFPnp +TlRTghTjwTDRTDlZZQgWMMrMJMSZmM +BzdNzNdgNNPfgdNsdQdNvVMLLVQVMcCRCMRmvCGc +zHpplwwZrZlqlWWrpZwqlHhLvqMCRDCGVmLcqGMVvCMmMD +rWrjwWwHplZbwpZtHtJJbgfFTfsNnBbsfbSdTzgB +jPRRppDLDGDTLLggMMjpLTGcrJWHsttJfwnWrMvrJnvnrNfJ +blqbzBdzmhhbQWnsNHtJvfssfd +lhFhzSzzSZVNSlVPgDPCPCGTRcGR +cqWcNWffPftvsvfpqPtZsBzrbmbFddBmbcLbdDHbHz +TJgljTnGgnLBTZbHdBFz +JgSnJwSlgGJRwMtfPtvfwsZQZZtv +hHhPbQPTwsdwdHqtgttjpNfjDt +FFlCmSzRCCmlzzRGCFNvRpvjvtZNZqsRfNRg +mVmsFMGFzJFBwQTMnMQndd +QQVpQGcVdGmspHHLtbqfqfbt +JvZTFDFzJzhFCWCZZDzWPBCJfLbnnwLqttnsHHNPwtbHLwjn +DssTMWvvvGMcQGQGld +sshRHZSZRbSZHhBFBMpMWpFgbbtb +JfjTjmwwTPvfTNPTQlmFFFqqmFMBBqFgFt +vDTvJffQTJjJvPvTNSHRzhCsShRRRDtZHz +NFLsRDNNDNBDlgPPgBglQlzj +HJhdZpfJzlWQjjHw +ffJTppZZqTNlGnNsMG +ZMrWcWwqqvPZMndGdqlnnDLnVT +HpCsshCfpFfHHJDDSlSVQQGGflDQ +zssNzRJFhjNHNNHpJRwbwMMzWWtZPcbBbwbG +HlNHHLHsBDRpHLlsHRlJnMhfWZMRnvCCCnWhZj +wtqSmQqttzSSQdPmmwZhChJjWJjPggCZCfZJ +SSwtTbTQmbtdqmGTTcfqzDLHFsBLDGLNGrsBHFGrLB +FFDvWznMWWMrPnPnWPgsmgQbhJRslHbwHwVVsVHjBsHb +ZtSffffpdLqpSCLfCNqfLqLCjHjHbwhpBwJllHlRVQllphjj +ZcNCtcGSctZScqfNGScLNcczPJFmzmDzGzWnrWFPFWDvrM +DnTPspmTPsTCDQWRZzZzZRCRfCfHfh +BNcqTBcFgbVchVJhVR +dTwdrBrwTSPPWnnmSmsn +pfbbDbHpNBFmQbpNNBSlLtlDStSdSPJLtLJR +ZcszvwgVCZswFzVTRTlTlRLgRJSWJR +jzZvVwFjcjjnwvzwZcjMpqMpbGQbQmhhHhmfHQmh +hTbddhQCtdNmdtwtdhTBbCddRSWscczwcRSWLJzcFJzDsFsR +NflgfPZPcgSLJcWD +lPVNZMMMpZlZZvfrMvpbQHQhtbtqdTQHthrqhd +JlWSStwhWJSRJpJvJBjTwTqcwTsDjsCTCB +dqFzgFZGGQNVmTcCrjrzsBrB +fdgLFQLnPdnqShRMPhlJMpWW +TMPcsPDjdDhsDcDcTTTDvdvghBNFGGtmNrSrgSSBGNtNFg +CVCbJqlRVVWWpRqRQZRWVWJZBtmSFGNmggGmtmmBFbrGMGMt +JRqHVJVCRLZWTjMnfLTPcfLd +TRTZFTTrghrZVhVWdWZpMmbzbdzBmtDpDDzmzB +wcsSSsjfPfGPqQwqsQcfJJCtJGpppCBJzCbzJzCb +sPjflcwljfjfvqNcTZTRhtVWrNrVLnrR +rVLLsmwmCWTmsCTdwQrdTmqWDjDHjNGNPbjDBPNDNsZRDBjH +cFcSvgJvfhfLnShtMJtPHRRvRbBBGBPNBHPbND +hgLcgcLpJSMwzmrmzqQrmp diff --git a/03/src/part-1.rs b/03/src/part-1.rs new file mode 100644 index 0000000..f682ef3 --- /dev/null +++ b/03/src/part-1.rs @@ -0,0 +1,54 @@ +use std::io::{BufRead}; + +fn main() { + let stdin = std::io::stdin(); + let mut handle = stdin.lock(); + + let mut buf: Vec = Vec::new(); + + let mut result: usize = 0; + loop { + buf.clear(); + let num_bytes = handle.read_until(b'\n', &mut buf).expect("IO error"); + if num_bytes == 0 { break; } + + assert!(buf.len() >= 2); + assert_eq!((buf.len() - 1) % 2, 0); + + let half_idx: usize = (buf.len() - 1) / 2; + + let half_0: & [u8] = &(buf[0..half_idx]); + let half_1: & [u8] = &(buf[half_idx..buf.len()-1]); + + let mut set_0: u64 = 0; + let mut set_1: u64 = 0; + + for c in half_0 { + if *c <= 90 { + set_0 |= 1 << (*c - b'A'); + } + else { + set_0 |= 1 << (*c - b'a' + 26); + } + } + for c in half_1 { + if *c <= 90 { + set_1 |= 1 << (*c - b'A'); + } + else { + set_1 |= 1 << (*c - b'a' + 26); + } + } + + let common: u64 = set_0 & set_1; + for i in 0..26 { + if common & (1 << i) != 0 { + result += 26 + i + 1; + } + if common & (1 << (26 + i)) != 0 { + result += i + 1; + } + } + } + println!("{}", result); +} diff --git a/03/src/part-2.rs b/03/src/part-2.rs new file mode 100644 index 0000000..e3cda54 --- /dev/null +++ b/03/src/part-2.rs @@ -0,0 +1,76 @@ +use std::io::{BufRead}; + +const GROUP_SIZE: usize = 3; + +fn main() { + let stdin = std::io::stdin(); + let mut handle = stdin.lock(); + + let all_ones: u64 = { + let mut ret: u64 = 0; + for i in 0..64 { + ret |= 1 << i; + } + ret + }; + + let mut result: usize = 0; + let mut buf: Vec = Vec::new(); + let mut done: bool = false; + + loop { + let mut set: u64 = all_ones; + + for i in 0..GROUP_SIZE { + buf.clear(); + let num_bytes = handle.read_until(b'\n', &mut buf).expect("IO error"); + if num_bytes == 0 { + if i == 0 { + done = true; + break; + } + else { panic!("Malformed input"); } + } + + let stripped_buf: & [u8] = { + if buf[buf.len() - 1] == b'\n' { + & buf[0..buf.len()-1] + } + else { + & buf + } + }; + + assert!(!stripped_buf.is_empty()); + + let mut seen: u64 = 0; + + for &c in stripped_buf { + assert!((c >= 65 && c <= 90) || (c >= 97 && c <= 122)); + if c <= 90 { + seen |= 1 << (c - b'A'); + } + else { + seen |= 1 << (c - b'a' + 26); + } + } + set &= seen; + } + + if done { break; } + + assert_eq!(set.count_ones(), 1); + + for i in 0..26 { + if set & (1 << i) != 0 { + result += 26 + i + 1; + break; + } + if set & (1 << (26 + i)) != 0 { + result += i + 1; + break; + } + } + } + println!("{}", result); +} diff --git a/03/test.txt b/03/test.txt new file mode 100644 index 0000000..f17e726 --- /dev/null +++ b/03/test.txt @@ -0,0 +1,6 @@ +vJrwpWtwJgWrhcsFMMfFFhFp +jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL +PmmdzqPrVvPwwTWBwg +wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn +ttgJtRGJQctTZtZT +CrZsJsPPZsGzwwsLwLmpwMDw -- cgit v1.2.3