From d032c762657585163a38a71f6b86cf6eb8c51df0 Mon Sep 17 00:00:00 2001 From: Jonathan Flueren <11487762+JonOfUs@users.noreply.github.com> Date: Sat, 3 Dec 2022 14:45:22 +0100 Subject: [PATCH] Day 3 --- Cargo.lock | 2 +- res/03/input.txt | 300 +++++++++++++++++++++++++++++++++++++++++++++++ src/d03.rs | 104 ++++++++++++++++ src/main.rs | 4 +- 4 files changed, 407 insertions(+), 3 deletions(-) create mode 100644 res/03/input.txt create mode 100644 src/d03.rs diff --git a/Cargo.lock b/Cargo.lock index f845529..0ccd751 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3,5 +3,5 @@ version = 3 [[package]] -name = "advent_of_code2022" +name = "advent-of-code-2022" version = "0.1.0" diff --git a/res/03/input.txt b/res/03/input.txt new file mode 100644 index 0000000..5533a94 --- /dev/null +++ b/res/03/input.txt @@ -0,0 +1,300 @@ +zBBtHnnHtwwHplmlRlzPLCpp +vvhJccJFGFcNsdNNJbhJsJQplQMRLQMlfdfTPCLfQQCT +GPhjcjhZDjWtnSVH +BNhHVhrGNVTbDHdDJdJRPJdSQQSJwPjR +lvtsfbsqzwSnJcvjSm +MftttFLftZMLgtgMbltMqZzbDNrTpVGhNWrDTrpTGNpZGZhD +VSSHcTgTtTdtllZlzmmbljTn +RqMqsFfQLLFLQFMMfRLPZLvPpCfWrbpmCbjCnfjlWmnrmmnm +hqRDqPDRsqNHwtHSNBZtJd +tNFDpDFrtdjfmjjjFmFFdScpZhZScTJgpHccHhMJgS +lLzSlSCQqbsVhBghggBZgCcJ +zRLVVLQnvQqVVzRldfWrwffjjdwSdfjv +bpWqqqWvHBpwGBCCRl +hJdjdJFQqdBBDMMC +tFFzJZFtJSqtZJQsWLbNSTnffHfvTH +lFhRZhFjPlqMlJqZJlJcRLwrLrwStRwtsVVtVSrgRV +WcpDvDfBmpDHzWBDbpbmWmNVSSTzLTtrVswgttVVzwwr +pbWfmGBpHfDmWnvvGbmWnjjMqPJMlMFPdGcjqPqPhP +NjFNRlpVLFCSSlbBWWfw +pssPZQQsMnzmtnQPttzDBbBJBcrrJWbrZSBJSbfC +QTHPHspMNGHdhvRR +QfPdSJfFJmthSthtwbsNLbPLlLTLpbvP +nHnMBnZqqgBMnWrZMqnZVcbCqRwNsvblRwppbllTsRNp +nZHBHznMnWgcrnVBtjFdfmzQNtNddjNF +hFhfPghppPhpRNhzsjsvHVzjpsGnWz +tTjlCCwMqtdMjMctGJWHwWnVwWnwvWGs +rZdrjBBtqdCtlcdgFZQLfhRLFSgRNP +RDHSWrJWffJFlJCgCMCDjCvzjPMP +QtGTndBwBtNzBVjBCMgB +LdwwMpTdwsRHsqSHqHJl +RfsfzvLLFvFzCSvSbDsTpTGMPMZPPTMt +jqWBjwBBNwWqwPGZbTwVwVtD +BnhgglhhNNngqjBjHNWrZLlFLSCJSFFCCQzQvQFCFF +HLvLDQbvnDQDvbHTLhntSnGBSlfGldddcmfMMf +NgFjZjrZZJrlfJfSVcBJGc +scWCNFZpsjzrDLwLhbQzhQwD +SlqJlThDPqpwSTwhcbDdbWDbZGcZNcDb +MsnWWjHjvLvfscjjgdzNdbgbcc +vQQvWVQFLLHfHVBWfsfmFFpJRhhSplqlRJqpBwlqTCPC +DZbDzzZDjQbPGZFFSSgSlFCzTgzm +qLnvwvhddrqMrwrCTLLFJjmtSlFlSH +VdhvsWqdVWvvRhsvqbpbPcZfPpjZGBQNRj +mJNtNFmzDZtzdzrLtwwRqJSchgfGcRfwRB +pWpjQjCTQnHMWCCpjQpHvTqcwTwScfRcBcSGBRThwS +MQHjvjVCCqsvljWnVQzLtNPZzmzLVNLddtPN +QVRPRVDgsRjLssnL +TTGDJDJfbfLHSnsMWWbs +qGqqTFFDqgQgQQQq +nlMnRRjbMjCdJVQJCZ +nGqfLwfNLFNLnPPGFVVCdVGZJtCtCCVzJz +LHHfPNHnPqqLwqPqDPWfNFvMglbhhbMgmclgcllDmgmrcl +cLLWWSThtdLpRcddcgPRZFDMCVPPMCCPCPCZ +NfGbGNzrBNffGNJjbPPZsZmZZPmDHpMH +zlJBfzlQzNjNjfJcpwSdvWhcvLwQWt +cVVQfVCJVrVcTJnfNvlDFmDrmlvrFWlL +snZHpMhZtMbtPNvzHWWvNFNvNW +gppnbbbRgMnZbswRqRwbqTcCCSTCJJdGjgfVGTdcCG +jplgNdrHrrNZgdHmlHNJHddlDSPPSTlzTSlTSDSzCQLfzf +vscvWWWvGWGGscbFMpRWFwQTPzfLQwQwPfLbzSzzDL +GvGBWpqcMVRNNZHgdHdtBJ +LchbZhjjZFjwSmPRqRffqbdtggdR +vWHMWlHJdGqtRqHV +MvzCJlnMnlTNnNNLLdhjjCdjjhDjjL +FNCllHFvCGvwQcPQJfgfmwgh +zjtRpbDLjtsrzbLLQmfBTgTBQQfhbfQB +WLgqRzqsrWvFGFZFZC +qjLlNcLjcNWpQLlQMmvmhCvCgsMZZghj +tGSDJtRGJzHMMGDVZCfvmfhzmZZgZsmv +BSSRDRHBGHtSSSbGJSwHbNcLQddqMNlrqcMQMldBWc +JSfctrtctDpszHvzVQHr +glCWjhWmFjlmlhmdWPhVVznvcHjszbvvpHvznv +FgBmFhCBCGFqglgmhCFmSTSRLJLLZfSRJcDSGMtM +vZGlFFtLMLdShSSShRVtVf +rQNvmznWPNCPNsrCsbWbsPCvjShhhfHBBHJjSJRhjSRnHhSj +mCNsQCmqszNcQzrzrrzWvGgGMgpdFpMLlFZGwcLDdg +QJRJQDlcqLlWbNGL +HCnwwsCrnstLWqtWNgZNgg +rsnTrTCHTnnVwnsVPqqDQcRjcczMPvPRzM +qCzjqnzVdzrdhnhddDbDBMPttcGBDBDPnc +sZgRQWHgWHHLsgsRRZsJbpJlDcDGNcTDFtGNFFcJNFPBPBTc +WggbRQSRRgRSsWWmbHqvVffVwhzvCdmfhmdV +lhqWcNpQGcNmmHmNPWCsQzQsgrQrBMCMbMVM +wDLFFDJvSFFZRDZSzCrzTzsRgVWbCrMW +dFwDtZfdjFZWFFfmHGPnPPmqfmPNcN +lcMRNJRGGLJnNVFbVrwrwZrD +tjCzQjQhQwgWFShVFS +ffHQsQssQTzBsPnLpMPRwsJP +MQSMSBSRFMQLJChLChjTBh +WmVlPrwnpwDlflNpDrNnDlDwThJCCdLJhhdhCfJTccGjvscd +gnDVnNnwgglwDwptSZFzgQHqbjZgZZ +nwBcFgwTDcNrpZMD +WQWCLZmvhMRvNjsNSD +CGGWmZGHHhtVzHbTqgTdbgzz +RmcTCwvssRbsThTcVRJJfSPqfJwJFqfjfMFq +zQNZDWtQlDZGBQPfFQqjJLjL +rrglggZGWnrnrrHlDhsbsPTVCsCVsTRpHv +wFGfzSvCPGttSzqwmtqmvvPRDDRCWgWWDTBTMcBcBWbCRM +hVJJHQHnpWnDTNnnDb +LJsVVdhQqvmdbbSf +srlJztzsVVsSsVtRlNllTWzzmqGhqWLPCDCgmChPLDdqCmCP +bZQMZpbvMBMgmDGmZLSPZd +MpScMSMpvfjMBcBcfMfSBnzlTjssNszrNrtlTVzlzFVN +rCtgrgClprGGClnJCZmwtMjZRjbjjcjZQv +PWVfBHWPdbNfbbRmRj +sPsVqFPsHWLhBVVqHFqPVddWSDLJgpTCnnrRRLGpJSSTRrgT +zjqpGjrQjGqSHCVvCrRZDN +cTdshMhdmcMNmddRHBhvCCBCCvHZDC +JTmTmJnLTdwzNQpPWJWgpP +BmpZmrzZnznHbpprSbQSQbqdSVqbPQcV +fRGTGJZRTTDwJTJRGDfgJgNFlSSFcldfdccFVlPlFFQPSQ +GvTTTZZLmsntzmCL +VhMcrmbhvzMSnhvftbRbllLtglBBtf +HqqqJqDqPjJPNjjDVFDZCdqBtRtGBGlGRfQQgttQfHlTQl +pCZJPqqZpmhvhpVh +dWLBJHJhGJGMBJRcDLDSQsSQpvcR +ZlnnPqglblfRRpSvSsnz +sPTgZVjjmwVTljrwTTlbwVGdJhBNNdFdMGNHHJMjBNFN +FhFrfbfgbLRdfqfrmvDgLdjrcQtSNStHHHQlSjJJPllt +CnspzZWTpCnMVzzZZGZRCzttHNjNlQlSNtNlNjVcjlQS +GCZsZBRwnvwfbqwFwb +bZnJFJgLFRnqQZqJQJFQGpCLNcGlLllClNtccjGc +rVfvwPDhPHGtlcbClr +mBhshsfMvBvqsQJdTbgnqQ +jgWHqMSWMGqWjWjqbWGJQDfVqLfrfDfJhVLfTr +pPplwsRZPFZFtLhfwgfwrhJL +zlRsdgFcRgmjdBCMHdjHWB +qJSGJSPQWzcprtQZtt +mBMVfsNBnZzcNtcc +LMLBsmMlvBgFsghVVvfgLBvbJJSqgGHqPGPtCWwbJHqCPG +ZvZLcdMGVMlHDvDpvqhH +NNSrQNbJbrTnnWZDDZqqhqpW +wbgNJrsrCwwJQZbsrJBFzjCCdzGdjcGzMdzj +JbVmdVLJJJdQMnzmmMgHjPqqjNgvqwngHNNP +ZfffDZZsRpcpRDcCRrlpplcWSSgwgSwjvvsjPSwhNSWggh +cCtfppZrpjtMMmdQQTLz +TtbnmbdmTmgTlPNhqvqj +wrwrLsVZRsJJJsfHjvPPWfhjHqRN +sDZwDvsCCQLJZQJQsMCMzZBtSMpndcSFnnSBFtSBmdBc +mWFTZdmQdZFrFQbCRsrspjSjnvCLRS +GwlDqcNHDzwGfHSRqCgJsSpnvpSL +NGlcNwHLLGfDDHDhDwDcwVczbPddZtMFWttWWtdPPdQdhPWd +mnfcZgcdZqnqdfFqPmHfhqsbgVMCJNMtvCJtMvtblTJtvb +rRLDDjPSjjPDGBQSBNbtLVtbMNNJlTMtbl +SzjDDzRRpGQDDDPHzdsmnnhsqcqdFq +ZDGNRDGjSdwnnmnsVNsHJJ +tMBWWrddLPLhvWTTPLccvmmbVpgsJHmccppJ +ClPrtBWWrhrFLBPlCRzjzGqdRzjRdRGZjF +csTRNQNJcNBDLfhfMf +qGmWpGHqrqPLChPRhVFPDD +tgHrtnrrJnZRTZcv +FLqrfmLDrqCmqjTqcbGqRTGVvb +FMtWMSWzzFStJzPzhWzhQvTvHVjjTjHTTHvbHc +PgtWWstWtSpZWPzWwnrBsdBDdFLfllLlfC +mThbMDMQDCDbwLqWpqPpdhwR +zgrcffgHNZltZSgHLsRsLLWRWgLqppsW +SVlSrfSHlSSVlrJfVctlNDMCmMFbnbRDbDBFJFbBRM +PrBrWqtRPdBLLrBwqpswgpwhgpnZhhzsgw +FTFRSVJQVJflFfQQgggGMZngGQZszZ +TbmfFJFSDFblSTDSFFbmVSDrPLLWtcmBqqRmBtmcLtcrjP +DjPsMwDjLVVTsvNNRTNTRT +ztdQQHqHlFNtfRNNNMgg +FzhMhHQlDcCrhCCc +zSHGzzmHgnnMDLTNTG +lPVBtvhQjpNSMWTLBD +VCftbjvbVCfPbZwsJsrSgSSZwC +CbwgmvMnmnCwMmwRQqJBGBgHZHpJHdtdZpJt +zVSlNSDlrzNhqlNTScDzVWfBBZZZZGBstGsdsWFpdHdJsW +NDlLzhrVcqRPCMRwLLLw +TjTHHLwnLjVlTwLjgVfvsFvDsdWfvDvFMd +qbRRRpmpcmDcczppztSqSvWFssFGfWdMvfQWdfsG +RZpqDBmtrzhzphjTgjHlnwjgJhgJ +dLmMgdgzwDLzDWFhBWvzFzzBZJ +tTVcppbSTfstTMMHfTbhBchhJFCWcjWBZhjGGB +SSSSNbsNRpRRsRrfVHfRpNtlPgQDLPdMmlDLlrPnqPdPLl +qqbTCSqdqqFZdRLZhwhZ +HWWlHtlrBfGtVssnsLnHfJVPPMMFzhPRwMPwFhzPZzPMGM +nfmtsrlsnrfVnHJrVBWlsVfgbbNTNSvmvvpcTjLjLbqvvS +GGhFvGPFcThqffPdnfNLqZZCSwtQSwZpwQQBsL +RglMRrJJgHBCBZSQQpdr +WmbRHHbzDgJMDzRDMdWmWHzHNFFvvGGhnvVvvfcvnFfcbvnT +QsfQmsLfZZZcshnJ +dSgdWgSVVFvzSpqFdqTgWRHbJNcbZNCTJCNNZRRCCh +FcpVjgDvVVFdVWFvzjwwQtBMLtBBGDwftPrB +rqsRrHsvsPqswNcJcNJrnnBrNn +bFjgGFdbVRNNnpRQpV +GSthhggGDSvMRqtHvMfM +ZwVPgMsgVsGzVsRZpgpzzgpFMrNbbLFrDLFFrrSDLfrNBN +qvnjBhQhntbfDLrF +CJlHHcHcTWqvpBdsWRpdPdgs +BjmTDjJBCBWrgQRPFlWWlW +dHphshtdtVHVhpJqspdvRrqFPgrLPPFPrrRPvQ +sdMsMtStVszpwMzHjJGjCcZjmScNfCDf +DmGdDffgDSDDdJstqdJldlRt +MhnvMCZCbbZHMvsCHtrcVrPjJcRqVtlt +LsQbsFZvZhQzZwhQWTNgBWpNwSGpTmfS +RRJQnCzbZZLTZJCBtWvFtsfqBqtfWb +prjlChGNldGNdlSVMhWfqWtfsvwvqsFtdtsq +GGjNDNhpMGMGVhrnZZTzcTHCCJcDHc +RmbMmjgpPjMBsBMfchhVsc +HwFWFTztSrtFpcQvBsSqVscBBC +zWwnJFHtWWHDgbGgdpGpnl +mnbWbRRLRFnmmWcCDTBVwCDBlwNW +ggJPtpdHGfdZtMHgtZgVPPBCVsPNBcsBTTDDCC +hpvJJTpGhdhtJdMHqvmmnLvSbmnFnRFm +WWtrWrNgVbRjMrQCNzqJFwQJFNTJ +LdHPhcdchQQssLzJrz +pBccnHpnrrcGHnnSlWjnRMSlbt +NMMfNFnZgMVThhTMcgTDJDJjsVvvJJqJmHsqHG +LQpwwprCQzBNBdGjGjHswswdvm +CBCzzCrbWbSlNQnTRgPPfFRWnfgc +RFwHVQRwFgTQSFVhdsdHsBdDBnnqnq +LGftLtPGGMzlNrhlPqPsrJ +fvGpWpMtccpTwwpRRQhh +TTJCGdTGtZRQQCnzcnCv +FWWHPSFNFbDbDDqSWnVmLRRjRRQLhcmLjS +qPwPWwFppbwggGZGfdJZgdnGdd +zSTWzrzWTLWpCtCGpqqGgplc +nZWwsJVZZBnJHJCclHllgtChgCgc +DFnVBJsFssVVFBFnBdfvjDSmTMWzrmMfRmTv +MJmgMssrsggqqMVstbwTcTbPbTTwThmw +NRBBGRjHVRRcRbCp +QnSfzLWzNHzNVQQVjrglJMsMFvgJdFWrgZ +ggLLGnhgnPvJHZnN +VBtmVSldbSBVlcNPHvjmNcwNZZ +tdWqSVSSBztVWGrThLhfrfvG +TDqrjdSwLqDppdTCdzPBFmmjQmhHFPFQhPFR +zlGbMcVcVtsPHFRhWRRsPF +btgvlVVcDZZZqgrz +DgwlgbbFDDjjPTHDrmddPhPV +WqtMBBtQsttMNWQBqsbJpGGzdPdTHLVmTzJhmTPhHHPTmH +qQsqGZNQtZGMNsNtZpFnjnCRbZffwwSRljFf +gMdFLCdnMZCTFFCqnTgWLCHfSgPgPHStcQQmfSBBSfHg +vrwwrwzbGjjswjvhGGsjPQmqRmHPbBtcBQtqfmcH +qzJllVsGVGljjsrzwDzhwzDGTddNLFnZWNdpCVWTNTZTLZCF +LtwMhDtctwbwwppdWBJQJBWPvPfDfqvG +FTzrNrgSRFrgzFRHNVFQJvlqHjBvQWlQWqPBfq +sFgNzmVmNzgTvVTMwhMhstMwZtsbsc +MrBDQVzzlrvhQzQrDMVQrzrzgRJnRRwwRbwSwwVRRNSgwwwJ +qFTPTvfTHcqqncpcwR +LmtdGGPmTPGCTLHLWsZMhvZMMMzrzzdlMQ +ZVNpjfpZNpfNgNjzNVfWtnbbWmBHtsZWBSZBGS +MrDrQvvDrPLDMvFvdmBGGsBBCtsHrnrGCm +ltRMwLLDDRlvQwvlQcwhqfcJNpgzjJpjhJ +sRRRlRbcFbBBdnFBwCGppNvGrTCDDGVNlr +PPSLQzHjzZZPLZPjgTNTgpCbVJvGrNCTGr +ZLHHPQjhQmWWSRRnssdtbnmfwF +GRwrMrHJGwJPGWsgfqQgsc +VbTvLQCZLSWWsgWf +TVDvVCvppvTDmzZVTbZpTzBBNQQQJlJBBJBNNJmRBwRH +shJRWJsjZGNjSTrjFS +dMLCddggldQzMCCVgzVVLmLvTwNFFSqpNSqSbFGSqTTpMTFN +VGQvVglCLcVzgdddCDVvlsPZRRBDJPHZWZZnBsWJRR +CrwlwhRCMrswnsHBFccHHWFc +QJTmtfQgLtzQfLQfdPcWSFHHDDSpcFpFBg +jTQTqbfQfmLbLQJbJrRCWjljZGjNrZlZlC +JmthDmLShtJmHphphJQCwjdjdFDzFgzFdgdNlC +sbMTVBrWMbNvVMnsWMnVzjsjwCfjFgfZzfdgdzlj +NvqbbBcMMPPSqLSpGGthmp +RfGWFHlPFFNWGFZRZBjvwCvzBwhhrvvjzmrr +sLJSLMSTSJTbStJtMSqSqbpMrvmrzWdvhmjDCzzwrrpjdDDv +SbQqsqsWcZPcQGFG +BjqbMqMVBsfqGqFqGLmF +ZZQbQPddPcwbPnRQltdtQZdnmFNrvfhGrhrWWFNWWtmNFNNW +dJJQccnRPpcbQcMHsSgSMsDMTJSg +WWGBBvPflnWbBWhvhbPvNfnnVCFZmVRVZmVGMVwRLCCCGwVC +gjszgTMrgzgqCRRdmJRjJLVw +grzQHzqczMSzqSHcgQsqPvPlbNblpPhhPPbHvnhp +sJDDNWdnRLTTvqwSFPCmLCCrCq +thzplgfjglflFcbMclpppMfcwPqCZQCmqCwrzCqmQmHSqPqq +MhcpFBMBlhjbBTdnNJWvNvsvBd +czwwghnWWfcfgwfWthfrvVvrjdrdvDDVrbzrLF +RHPPMRpQPRMPPJRjJQsZsrrvvJBDDVDVdFqrBrFdBv +smjMsGZHRsHSmRQNGHPpSTwwttCflwngnChcCtWW +bprrrwrtLDtrWwrQjRDQDbPPVHVmmmmHNWlPlVNPZZlv +hqqhfnBCTfnnhzJwzsqzfPZZMCCVZVHHFvZMFvZmlC +TzhhdJTqJzcBdJJnzjtQrLdjwgLtpbgrLQ +qzQvzzgWSCqtqqGpddGc +jLrZNZhZrNRLHNffhrjNjNdtdZtGcPFwFwpbGwbVpdwC +nHnhrLNCCMHmhHBMhrzvgJvsWSWMWzzWzSlv +RzcbzdRFzbbzbzbFdZFTHMZPhVhVQMLrlrQPhLZlMM +BNGfBvsNttVmMhlMLm +BwGjpllswfjwpcFDWcWcbpdb +SjzpswrLSDjVSpwlmZJBTBdNJLvBNvHQZT +rCcCtbqgCfthggtbGGMqqghqZQvvQTBNJQHQZQTcZTJFZFFd +CggGMtqMfWbbGghPhhbCMtmsSppSspjpmWzjVSWlVrrm +PmWTPThTQWnLWQFl +VNcSVfMbtsddBQNnNpdl +sSjctwjVSzzccjgnTnDTHRDhqjRR +WfMWfCNCjWWHNTccMjRjfRcMbqSwfVwqwsfGGbssrJSrswVw +llLFQLlvlPFnhQBPBZQBqvBwzSzGGhShJVwShmsJbbmzSG +lnPqvQZBFFBnnpgplFvtvHDjTdcTjTMMjCRNCMWgRC +rprFNFFNjNLmMdgcqL +BvzCQQbBQgffsDbvVHMdbcVqmLVqlmqq +JvJCzBDJwnsRnQDszCBnnnQBrjZPjFpgZFTFZRpTrpZFGFtT +wBHQQZHVCcpwDgdZdMsZjvMZFn +GPSzlNlJLfzzzvsWdWLMmFWLMM +NfqGSfrTNzRTqJfRbptQHFQFrwrFHBHw +sNjVMVNVMzPzQgghcMsNzJtjSJtTFDTJtJnnDLjDnL +CHwrdCpvCrwrWdpZqcpFttJSFJTLLHLJfbnbfD +qrlZCwlqZrqqpWdlRqCRqdqcVNsVMzQzmNgNPBsRhVQVVzMs diff --git a/src/d03.rs b/src/d03.rs new file mode 100644 index 0000000..b3e054f --- /dev/null +++ b/src/d03.rs @@ -0,0 +1,104 @@ +use std::collections::HashMap; +use std::collections::HashSet; +use std::fs; + +pub fn d03() { + let path = "res/03/input.txt"; + + let contents = fs::read_to_string(path).expect("Should have been able to read the file"); + + let cont_arr = contents.split("\n"); + + // build alphabet as hashmap + let mut alphabet = HashMap::::new(); + let alphabet_chars: Vec = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" + .chars() + .collect(); + + alphabet_chars.iter().enumerate().for_each(|(i, a)| { + alphabet.insert(*a, (i + 1) as i32); + }); + + // parse rucksacks into 2d i32 vec + let rucksacks: Vec> = cont_arr + .into_iter() + .filter(|line| *line != "") // filter out empty lines + .map(|line| { + line.chars() + .into_iter() + .map(|c| *(alphabet.get(&c).unwrap())) + .collect() + }) + .collect(); + + // 1st task + // calculate results - split each rucksack in half and find & sum up duplicates between halves + let results: Vec = rucksacks + .iter() + .map(|r| { + let (r1, r2) = r.split_at(r.len() / 2); + return first_duplicate_value(&r1.to_vec(), &r2.to_vec()); + }) + .collect(); + + let result: i32 = results.iter().sum(); + + println!("Result 1: {}", result); + + + // 2nd task + // calculate results - find duplicates in each 3-rucksack groups and sum up + let mut result = 0; + for i in 0..rucksacks.len()/3 { + result += first_triplicate_value( + &rucksacks[i*3], + &rucksacks[i*3 + 1], + &rucksacks[i*3 + 2] + ); + } + + println!("Result 2: {}", result); +} + +// returns first duplicate value of 2 vecs or 0 +fn first_duplicate_value(vec1: &Vec, vec2: &Vec) -> i32 { + let mut vec_set = HashSet::::new(); + let mut res = 0; + + vec1.iter().for_each(|i| { + vec_set.insert(*i); + }); + + vec2.iter().for_each(|i| { + if vec_set.contains(i) { + res = *i; + return; + } + }); + + res +} + +// returns first duplicate value of 3 vecs or 0 +fn first_triplicate_value(vec1: &Vec, vec2: &Vec, vec3: &Vec) -> i32 { + let mut vec_set1 = HashSet::::new(); + let mut vec_set2 = HashSet::::new(); + let mut res = 0; + + vec1.iter().for_each(|i| { + vec_set1.insert(*i); + }); + + vec2.iter().for_each(|i| { + vec_set2.insert(*i); + }); + + vec3.iter().for_each(|i| { + if vec_set1.contains(i) && vec_set2.contains(i) { + res = *i; + return; + } + }); + + res +} \ No newline at end of file diff --git a/src/main.rs b/src/main.rs index 6079db4..e501288 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,5 +1,5 @@ -mod d02; +mod d03; fn main() { - d02::d02(); + d03::d03(); }