no need for this comment

input/day_3.txt

@@ -0,0 +1,300 @@
+ZTmtZvZLTFNLMQMNRvZncdcHwcScJvcdHnVfwV
+zqjqrzqjCqrjtqWhqChqrznhcfdfVnVSVgcffcgJcSgd
+rtDGpzjjqjlrGsWqBWFRsbTPFQMTbRNRFmbs
+FFlnlnVlmQqcBVhBRrSrGSwVdRJbztSt
+NPPNsffWfNztRZSJNG
+WpgpTTHDpgTDDpMLPGgMHslmBmmHcBQnFmcqhmnjlqQm
+VlVNLlPQhtnDRPnP
+QgqTffzZqgvgzWmqqZmGcDthtRFvnnFnhJtJJDDt
+WGTBzSqBQTQmZBWHswpNbswLbSNCNl
+PFzFQDdLjMzzQDhnDNmwZmqwRsmRRmMVNM
+GtSbbtlttvvtBvtHBmqqNqVVwsVgCmRw
+brlvctHfrlrqvGvcTpjDdFnLDhdfjLhQpn
+fTqzgFrcmzTrTNgMzFzTrgtbMtVMVPSLVbvSStRttPVV
+lsHnlQhplQpsHhlDJsswNwZPZZVNwvnSZSVvVS
+BJpsGWhWQQHdGHlpWpfgrmqgNBmTTBqzTrzr
+PLPPrDNHDBnrWNBmjDmjbqqgzjgjQC
+GJpFwpvFFsJpwvwwGwJZJRptzdQSSZTmCjTQmTSQjjZSggQQ
+ffwGGtJGCfLcNMNNfNLW
+nlTzllGwlQHHGMSrrhQLcvbcghgcvL
+fFNpttBRFFRNtJJnfNWmqbhhZrZrcjgpvLrvrvcvbr
+JBftFFsVRWtNWRsmWtRfftGHGPDDCnTDHSCwzwVnwGSw
+LsrZLbLmPSTZtPcc
+zpnpljpdwhRpfNLlPWPtTPcnMWPcctTV
+qlhNNjldqdpgqdfhjpphdsgmmrDBBJJQgHrmDHLQJb
+ndDrsBbpqspHCjzVBCHjMj
+LWFcQFQtVVdcCMHC
+RLthwTWLTSLwTllRLLlLNlPpPGfrGnqDdGqsZqsZsZhb
+jHnJLJrcBbrRHJpnLBBjdHbjfgvGwstwWwdsWWshfhFzFfhv
+PZDQMNTMQwtgvGTGhf
+lqlPPQZQVSQCPSCPDmLppjqRqHngLHjRgLnL
+MfQrhdzNMfMPsNNmPmqPLCLCVLBnbP
+WVtcVvJJVjvFZZmgGjnjLBjmnnHB
+FFtcZRpWJcSDTwlVMhMDwrrDzM
+bSMbrQGZwwqbrbGMdTQGMwQdfFBLDLHLHssDgsHHBJDsFfwL
+lpPPCccvVPvccPzcWLDJFJBsBzJJHsqHjg
+tnqlPlVlNvNZZSSrGGZb
+NlBBBBBwmwcMgLwLVVLLLscHdnMDdbHJCbdvJbPdDDJHvn
+ZRWQWSfGhtSjqZhffZhhRjtdvPFHvCJbFdCFFDdHJdPb
+fpqGhQWWZRhfqRSqrpGllLcVLmscgrLwBmgCzN
+wHHHwDNCzZwzZfpzwsswzfzvnvnMDMgMhMGGFGRVdMnvcF
+mLtttqTPBtSJTSBQWlmcMvVdclnvhFggdGhRdn
+QBLPSLQQWmLtTBtBSjZfsbwbHzpjGzHfpzzw
+zDPBqBPqwzzsqlTzzPzqjttNbCPJVtPCbrvjvCZP
+MFhMhGfFfGpWWpHhFfRpHjVNbDbJjVMjrVvVNtMtbt
+gfRSmpggSFRgfGRphFGgfgBSBTqzSsdlTLqdsnsDBqLw
+QTTdWZZZTrhCZrjhVt
+SBJJNRRvvRpwwspNSpTPjCMVhhtCjGThjBjB
+fJJpvRRwNRSwvzRzRvzSgSRNqFTFDbFmqncQTbdFfnbDQnLW
+wSjwwjWhbhhjWjdqSVpqSndvMdmM
+NTvPBrZgPPHDFrFHGvZHRBqVBpCQVRRdmpRppdqM
+TgDHZPsNTWbbwsjtvw
+HVRPRwJVppQNpGmvMvmqqq
+WcttbWsWsdDdbFDSSWclZGvFLMvfvjfzNvLGzLmfqv
+tglcmSldWlBQBThRQBhg
+LDGGfPFLGsfFnGLfMzfJVccNzmcmwm
+qggSRgtjgCRtdtNZCJMCcZwTZVcm
+RBbHbbRRnLBDDrvN
+pThhMtMtTsWspWTnGjpsVHPdjdjvHdgVvLDVVSjd
+JQNrrwCFrSRLRVLnSN
+JQcJFCfcnfQmrbblQqlthGqzpZpGTBMWTMqtst
+DzVmzDDgsNdHHLGJhJppPPllqSgbql
+jrBWjcQMCRchPShwSblpbW
+ZjRrSCtnnrtBQTcrSZmGtGFFNDHmHVVmVtzz
+GSbGbrTGRRScMlVFjfbqqjdF
+tvDmZhtNtHDttBhCmHDJHNwlpjslMwfflvpqldsFpMlf
+HdBhLDhJDLWWLDCSQGcrQPGccLTGcQ
+tNzrCdJBrrtQdtgQdlQQtrnMZhMTqzHqqTFZZFqTHFMV
+bwbsRDvfwfsfcfSFqMmqDqFVNMNVVH
+PRvfbSjNvPWPlLllLJ
+MjMRRNRMjZtGVGpBCMMCDV
+vwfhFzhvcJQQwJlQSddzQwFWGqcDpCDqBqDTcGZTTVTCWG
+dvFJzrfZJhddLNLPHsrtRbPr
+BmbsFNBhszGgGtGl
+MSHVwdSwZflGlcqqpM
+QvwZCnnnSvZdCSWrNmDlPPBPDhPmjW
+MDwpRzRwMzMsdVSjdMWWMQdW
+gmlftnDtHnHHVWSWBjWjWgvW
+HbtrhbbGRNDpbCDz
+cjVGqQqVqBFhDtvB
+ZnTTfTffZZmDhBtJZG
+fNzbpzlHTlgHNzlRTlRNbHrWwrCwWSSdQddNjwVcjGSd
+WWrPMhwhnjpSLCpDlSSW
+sNGBGdmTbZNGsmbstNLZGZDBRSlqSRCfRSCqRRDDqCqp
+NvvcGtsLdTNZmLTmdJPcnnMFjFMcrVJhMF
+wMRQMSQZHznRsqRbWp
+ddgDDhfDrrDdjthHmdHrzpbVCVWFpfVqCWpWqpFs
+hdvNdHtjMLJZvJwM
+nWzZtWzHzZWgQHMNLDMDfDBfQbdD
+MCPmRGGhqdmNjbDN
+FRPlMlRChCvFggWZsHsZHn
+ZGhhjdgwgcZHsPnRnSnbWscn
+tltlfMQQQftDFJpMQJsWJWJsnWBnRSBbrBWP
+lfLDpQMFMNfLjGjPPgZzwh
+HcmvWcqnHLLPDzPPHM
+MGGSfdJRdCglfrLjrjrLzLPzlF
+CsgRgfwgdCwhsssJBBwvcnQnQNMvQtQm
+nrVbwgnSTSgSnrZpjpWWqmWNHlqqpV
+BcBPhSdsDlHNtNlJNP
+RLFCQLQRRsBDDcRdGDddhCRDfwzvSCnzrbfrMfMgznwwfbZv
+HJLzLNwBNzNJLzBJztRGzQVnDgwsjbgwssZwnDZbDQ
+PhvlSvvPfMRlDbDsggbSjQSg
+mFfhMlMrfchvPPpFTPvMvPzLBHWRHJNtzJGzzHpzBtCC
+FLsgSLzLswdFgLBbWZnJDWHcmZnnBjHM
+rpbrrqfqpvCbqqQQvvpClblRDHmjmmjJJZZnWMJmmJmmcRMc
+qTppQvCfhzSVVTzbdL
+ThTJtlqfDrDtffwqRCFCCnLwdnmpzRdF
+WPQSSFsGMgQZWvFQgZgZQcCdmmzLMLCpNzCCddmLzdzm
+cvVPGPQQGsZsgGPjVFccbHhThJHhDqfhDDjHqDrr
+CgnCCnPMnMtGHDbMFQ
+zLpwpRTwwRwhRchHwmqmGvvGbqmTmNQqvq
+sHdhzlwrRVrdLzRrprrfjgfjVBnBCfSBZZgPfJ
+SPMdWwWPrZwdrrWrSPLFDfgbQDfwDFfFglDQ
+qLGBtGLpjzqmvQbvvpDvfFpR
+jhLqqHBLGjtLqSZCssSTZZMshP
+MhJCpPDpRRFRzQQNNqbcZjNZmVhjNm
+LLSlLnGDmNqLbNjb
+sfBngrBSTTSnSGHlTsHBGsBpFFdRdQPDCFPWRMzzdQWM
+ZQtmgtWfPcgPgcsb
+pvMhFThpHVTvPbcFcFJLJDsd
+MTVHchVVHjHHTcpjMVBjjnQnGqQZnlqBmrWQQBffQQ
+HfcRNJpJfhCmpGSqqGNjsjBnQl
+tTdPwwtLTrrTVPSnQsbGPsnnlFllFQ
+VvvTSTwWMrSZVwwrrmRmczJchHcHCZhRzD
+wfRwhmLRnvrHqHhV
+bJlBHlWlHMBPJzDlzMMJJSBlFnrGVrqspGGvpVGPVpGsVqvp
+DWdStDMztCCHgZCtmZ
+MHdsznVDDfcjcjDcdDjmMSCQwQpCpFCvqSZQqFzQpQ
+lhJnLJJnTNrWTRqvqqPrFwZvwqQp
+NghhtJBtnWLRTNjmcMDtjdsMfGDH
+jgsvPffVmHfDqPSrNwnQwnwNhSvw
+PZbGbCdcGdRCGtntQLQQLLwtpLNw
+RbcPFBRFcdZBBJDBmTHjsD
+dTTFJdzhmmmQpzVz
+jtNLcctGGjtfrnVMsNQNQVVWnv
+GcrcrfLtDggLftDFhZFdJFHJBVFBgZ
+TTbqTgqCqZCrwmhQnnmrgh
+MhpfsMLhfmrznLrQrF
+RsStRMtjpHMfDtWsWsNDppsqlZqBlhNlbcNdTPClPqcvBP
+lRhZPgnpRGZlSrmsLSvSzLVl
+wwHdHCfDQCJHdwdDMdHCcDsLmNVvzVsWrcVNcVzLbrLz
+dMCCwCtJdwDQJMtjhnvhpPhRZBhR
+pBqMZfDffmBnvnNmPt
+rhwLHCChrLPCMNWMCNmW
+GSMVRSVwHLMRJDQJTZlJZR
+sfstzPGRRBSngMfQLNNqgWLQLZZNgq
+scVDjjjCDTVhHlDhHdvvjwjHrZmWQmJmrJJWqNqLJbrcQqZq
+VvHlVHldTjvhpVplhVThhwjlPFSzPfGzpGBnsRffRRBPPGGF
+WNFNfnWTSLSJTnWShTvVZCnvrdPrZvddVCrt
+QwsMjppcpHCPdHsvPZ
+lcwMGgpcGbzQpMgQwbDjDQZSJTRfShffWNJSSNFFbhSb
+JDNgTgqDTggQbQGbZDWbJmVJrPVfPjlPfPwlljJC
+FZzHFSznZZtptHzcSmCVrwfPVcwwVrCcdm
+nMSStvnZFSHpLLtBtMzHnMWQvNhgDgGNRGNhgqRWTgqg
+SJcrhvbBLBLrDpllvnwHQRnllHnQ
+ffsjfMMZfVdCCgCfgTzmzslRtwFwFtTnqqHTJRQnqRqq
+CVPgmdggVjCJSrhrbrPrrSLW
+LPtcLtgddLMRRCMRpTBRrZnppvvGRvBw
+WNNJjDjqSjJSqWqzNqzlSlBTGGFvrppSrwTFpn
+qbNDWNNHbJqVtctwVmsfLCLP
+FvSSLMqgvVSQjQfgwpwWpj
+BthszRPRRNbNtzmHRbHNRNPfwJGcsswWQpffJpfsJcQFwJ
+bBtzPmRrbBRHtNCzPhqdCLFMLSSvdnvCTnML
+VPHWJPDjVLDDjDSFDJhgdnNGdbblzTzNjlnNbl
+ZprsRZMQwwmGZsvtQZgTfggqnbfdTzrbqlTd
+GZMtsscmsRZswwBQHBhDDJJPPCPWSWCJ
+mNDNNmmVMSVgGgGGqsqGLhQqsLGhLq
+nZBTZpJPhCpnnrsqbbcfczJfFccz
+HpBZZRPRHjnPPjrHnRtCZnBdShDVlMDNDgVmtmDdVDWSdN
+tBftztmztGBBCBSGHBmhvHHcchbshhThpbLJHJ
+wwzMrrMnQdldVdMvJTcLNnphphbLJv
+ZzwPVrWQlwrdStGGCWqDSSGW
+QwfrQPvhwPfzQrvWWpQpvVGGTDGsjbgNNcbfsGTsDFgG
+CtddSdZMRRdnJhRnHtZtlRMbGGDjDgggjNTZDNgTGFgGjc
+mdmdCnHhVWmLmwwL
+zLcWSWFcPJLWrWLSZrJLjVjHtjVsrdtstHdtVQgg
+nChlwwnmhlCNqhhjHMgDjVVdwMjdtd
+CNnBmNNThhhdhCdlBGGlGvNpcJbJLSbcZzcFJzpJTWPbzc
+LdPZTPVpLCVTtCNsNsfFnlDC
+SMwqcqcWQMbMhWQzBnsNfsFwrnnNNlrs
+WMMWhvQRNNNjvLgZ
+DWFGzrtfsZHZZMLt
+pNwNzNCNTpppmnvNMTLVjHLBLLjMRTLH
+PPdlPmJJNNClDdcdDDfWhzrW
+nSJVSHQQnwLThnhrML
+ddsjfRdGZjmGjRTwwTZhwrMwWwtb
+qCdfRdMmgssPfjsdjdPspBzQpScSSCBpzNBQzcQz
+fJnmRMJrlrmRmTRmbqssWVdqNVQdswdNNb
+GZggFHGhHHgHSFvtHPPPsfwgwNsVqjqNpNjNNssN
+PPSPDDBPBmBMlLfmLr
+BdqdCBqqCVPVTZBrlJcTcTJTcfcbwwmcgv
+WjGGLzLMhpWQmRGhpHfbhcDhHHHhgcsbJD
+tQzSGjWRzWBntntrZmVB
+clfLQLgfzfTLDMwNrNrrNDGCGG
+tmbpFtBvvmvdQQdFQwMJCG
+SnbtnqnSbnQQsBqzgLgVsLZTLTPfVg
+QnQBQQBVzqqzpmfgBpnqSDFPjhhWsFVhlsFFsDstFs
+MGGrTHcvRTTrrrCDpjvWtFPlFlsvjp
+bZbpTpJJBBQmBmJf
+dNVgDdVtPcNPhgTLPLpTPlnTHHRn
+WrvjvwjWwfwWjGJsrwBjQJjTQLbnSTTmpTRQSTClHTbLmn
+JqWWGvBJBwGJfJJGvwqZZddFtDFhgDqZhHNM
+VwJcNgbfvfJbfcmGLZfPhZLfZGTDhP
+CnnrlBlprsBnzQFntnZLqDhZZqThWGtWWSPL
+FllFdCjzlsCzjJNJGGJwHHVg
+fTbVBmNJCJRVbTmbfJFHsDjQHDHQjnQRsvDn
+cLWcrGtttddMPhrPhPtPrtzsnSQQBvHjFpFSpDHsMjnvjD
+PrPgPdhGWLrrqgdqcVCffbNblBwfVmwqwC
+gmBfbmlbBDqrdfrDcJ
+PwVWrQphQWWhQsJFcMPqzDdcJq
+QWCSSHpSQWCttQpCRCHNSlZBtrmBZTjvGgZjmBZjBn
+JrnhMPvtVtPVHJGrBrQwTmQmRGGB
+pSSZCFClCbbSLbljZlSlFFszzBwcZNwTzQNDmBwGTBNTBz
+ldsCCjpFjCqdLgsFjpsLFQgtnfqtJvnMtnvhWnHHMnnVWV
+hzNHzHjWNzwHjjhprpGvGgvGvvpv
+PLBVVRPDLdrgCdMrdrdC
+FmBTqTmLPrsFqTBDcTTVtNNJztqWQNQtWWtJqNNz
+fFffFvFBgHQWHdvfGglBWbqbPSSbSwVntPhZwwbS
+jJCMzNMCjNCLNMjjphPSPqhbqnwPZLSqZh
+rNpJJDzpcNMzzdBnGcQTccBvgv
+FRFMwsrzVtwstgbCHHJJPgNb
+hfZGhZDnnTTHTCCNzJjH
+hppDvznmZphZQVFQwFVWlRqFls
+jrjrgdHdFBZsBlcCGghWNgpgbCCp
+QwJJqQQMLwPTwLMMwzvzwwzhCWbvcNcCChWpchWbNGfFff
+qqFQJTmwJSPjZsrlnBjdHm
+QfffRppWfHpQSrWVpSGmGMMccSjBjmmGmc
+qdzLvbwzwdsWwnFdBBcBhMjMDvBBcBhc
+bPdZPqddqzFsZVRptZZQHVWNpN
+BzBQQHNjTSzzJDDFZFgJDJ
+qLvCnLpfCpqCnLJhntRglFncDrGrllmZFZlDrc
+JpqvfhRhLddfpbbtsdJWjHSwHHTNSQNPTVHQTb
+qVQCCVlQZWgHZMqgqWlrtScFwrmtmcJqSSsSJS
+MzdnddpNLzhRpzbzNPPBbPScjcnmrwSFjSjSJFtrwjcF
+ddTzRMPLdLbvhBRdLWGQClVVCWQZQDTGGf
+DHHTsldDNdPnVDCRDCNHllHwcMpprSMpRmphhRWhrhmzSS
+qJLBqQLvJLQgftgPjJrhrMMWSmWMmMrrSqrc
+FjfFftgLBjJPBLQZGvvZtNClnTTNGCdHTbCCNsnslH
+jHHNsNqhjsShsshdRRCDMfMbCWHBrGGC
+TJQFmnpgmTpBDCgCMCDZCGDC
+FwpQzwQTmVvwTJmFJzTcQSdhBNztNPNjSlqLhBNhSh
+vBCfSDcRMfRcRHSRRZZtPwrWWNtdSmrNVGSdwm
+gbLnTzqTbjhGqFzgWrtttQtrPQTtNPmP
+zbhjzglgzzlBGcsflsCl
+jNHDNNHjVGVDNQFDTQSFZzDQTd
+vvLwhbnpvPPgClwnfFTmTZQgffFFtTfc
+LrhrLvwrnJvhCHVVRZNMjsRJVB
+ShfcBWfvdhhJBBVwCJjHTRNwRVNC
+qQzlDqMDDDslPqGVLTNZVpPwTRZZpV
+bgbDbsqzsDTcfrgFFdgg
+vlRHvvHwvMMMTTlvjmRtBjSJmSnDnpdrpSSrJJnDQrLp
+cPfCgZZzNzzcGhNszcTPNZLrnVSJpJhDrrhSSQSpDDQn
+FbTgbGcgNgcFbPFHMqvjjRtjRWvFvt
+fZTnqfFFDNglcjdjZcfLGQJBwrGGQwbGQTBBJz
+VhvfvsPpWRChmphvRGBbBLGhSbLrBQBSwb
+pCsCsHvsstPsfRMMMtmDqFjngdFZqDHFnNFFjl
+PVVwffMlfGWMDDSwfDwVpRpsZRjBHgpSsjJSpBSp
+TdnFbqTFdmbjctcqcbRBZtJJZgsBzBBzvgHJ
+bNmbcqnnbNFLChCVCfjDfWlMjVDPCr
+JBLLjBQccLLJhcBDDlSrdFDsVhrVsR
+HgNWCgqWGbvCRRZvGWvZmszsSlrWdSdFrWzSldDF
+qvGCZGHggRNHvGTgvLnBjpjjPJwTPjLcJj
+GCGwQrwBZMZdGVdLzbqbbp
+TRfTTCtgcDmhtDmsTDVSbvpLdNpzNVRqVdVL
+CfDJjscgTcsjfhtFZljPZWZMWPlZjQ
+WsrjjfRfjjZjwjWjBpDpVpVhMBsMMSBT
+JgmqHnCHHPCCtCJgSZMgZppDTgzvzZMz
+HCGCGqqqCtmnHnqLFHWjlFrWRRbfjZccNWrR
+BJBfSfPLPvdhvrbbvpDsHgDTzgpdzgZpgN
+cVcmRnCWCqGngHpZsZsTsqNN
+jmGCVwWjjnWFMjGwcwmrLJbBJPbLSrPPTbFBTr
+SPZmmtlmqjZlZMwhlrtggqGGcCLCpfGLgqdCqF
+FBBVDVTVDJfgcddLCDdp
+zzVHvVNTbWJJTTRbVWBFJbWHmwmSPlMjPSShjlhMhhrrml
+GJZJZTsnhsDJtVZdtsZJZrBCQpLjQgBnrQgjCjQQQj
+RPSfqcRShHbFcPSfBqLLprBCwrQQQCqg
+zPzPRHbFPcRRRHPclMhSfvfZsJZVTTZsJNVMGWGVdGTWWD
+lCZrCLWCwVllGzWPPBMTFpsbGdsTpsbNMgFb
+RDjtjHcHjcHctDRtjnhtnHTgMqTMqhTbdbdZbgFqZdMN
+vfDmvfjtmvtcHmjZfSRZHQzBLrVLCJLJLfJBPzVJlwPw
+JMTHVZMWNSCwCwMS
+nsddQbDCnQQdDBPdCQCSvwpDvwffhfSvpmppvp
+BssqBFtqRHgTqVRC
+cWTTthtrgrzpCdCddtpz
+SSSLNJLGLSLfCJfJFQCJzQ
+swMPMZVMMSlMSZMqVSSHznzcqgzWTHgTnhbnrr
+RJjjgMjWShPqchtbVBPV
+DDddwCnZMHLLvDnfLrvvbVbbBtpwVBVPwtVpbcbb
+zrvnvLrlZCHrfZZLffHZHHTsTmsQgFQSFTMjjQlFTRmR
+zhTTMLRVTzLbVqwVRJgDQQsSCgCDNgsZCpqp
+rrmrBmmWrWnHjWnGWrnGnhDHSQgNSpQsCgSNgtNtDDHZ
+fBrGPGmGPBcTMfLhJVTc
+TbTCjTBSbCncHsDZDZPhZbzv
+rMwplFdlWWJMJzhhpGtHtvHSSP
+fMMfwWdWrNfJNdlVgMcTLTmLffjTqnLScCjL
+SwhTllwJDwqqBWLBbNtfhjBB
+mvllZMmRMZGFZRfctLWtWttzfNLR
+MGvHMCGpVnFGlgvVFFnpnGmmsHrDJJdSsqPqJSqDJJdTTDqD
+QTTcqJZJhHSpShhFpFzjDDwwsFzpdg
+NBMnBvmBPvwrqvgvvqgD
+bNNGmWmbbClQTQRqchhQbf

src/day_1.rs

@@ -1,32 +1,22 @@
-pub fn part_1(input: &String) -> u64 {
+fn elf_calorie_counts(input: &str) -> Vec<u64> {
-    let elves: Vec<&str> = input.split("\n\n").collect();
+    input.split("\n\n").map(|elf| {
-
+        elf.split_whitespace().map(|meal| meal.parse().unwrap_or(0)).sum()
-    let mut highest_calorie_count: u64 = 0;
+    }).collect()
-
-    for meals in elves.iter() {
-        let mut elf_calorie_count= 0;
-
-        for meal in meals.split_whitespace() {
-            elf_calorie_count += meal.parse().unwrap_or(0);
-        }
-
-        if elf_calorie_count > highest_calorie_count {
-            highest_calorie_count = elf_calorie_count;
-        }
-    }
-
-    highest_calorie_count
 }
 
-pub fn part_2(input: &String) -> u64 {
+pub fn part_1(input: &str) -> u64 {
-    let mut elf_calorie_counts: Vec<u64> = input.split("\n\n").map(|elf| {
+    let mut elf_calorie_counts= elf_calorie_counts(input);
-        elf.split_whitespace().map(|meal| meal.parse().unwrap_or(0)).sum()
-    }).collect();
 
     elf_calorie_counts.sort_unstable();
 
-    let start = elf_calorie_counts.len() - 3;
+    elf_calorie_counts.pop().unwrap()
-    let top_3 = elf_calorie_counts.drain(start..);
+}
-
+
-    top_3.sum()
+pub fn part_2(input: &str) -> u64 {
+    let mut elf_calorie_counts= elf_calorie_counts(input);
+
+    elf_calorie_counts.sort_unstable();
+    elf_calorie_counts.reverse();
+
+    elf_calorie_counts.iter().take(3).sum()
 }

src/day_2.rs

@@ -0,0 +1,134 @@
+#[derive(Debug)]
+enum Error {
+    InvalidMove,
+    InvalidOutcome,
+}
+
+#[derive(Clone, PartialEq)]
+enum Move {
+    Rock,
+    Paper,
+    Scissors
+}
+
+impl Move {
+    fn from_str(input: &str) -> Result<Self, Error> {
+        match input {
+            "A"|"X" => Ok(Self::Rock),
+            "B"|"Y" => Ok(Self::Paper),
+            "C"|"Z" => Ok(Self::Scissors),
+            _       => Err(Error::InvalidMove)
+        }
+    }
+
+    fn beats(&self) -> Move {
+        match self {
+            Move::Rock     => Move::Scissors,
+            Move::Paper    => Move::Rock,
+            Move::Scissors => Move::Paper,
+        }
+    }
+
+    fn is_beaten_by(&self) -> Move {
+        match self {
+            Move::Rock     => Move::Paper,
+            Move::Paper    => Move::Scissors,
+            Move::Scissors => Move::Rock,
+        }
+    }
+
+    /// I don't really know why, but these moves have different scores
+    fn score(&self) -> u64 {
+        match self {
+            Move::Rock     => 1,
+            Move::Paper    => 2,
+            Move::Scissors => 3,
+        }
+    }
+}
+
+enum Outcome {
+    Win,
+    Draw,
+    Lose,
+}
+
+impl Outcome {
+    pub fn from_str(input: &str) -> Result<Self, Error> {
+        match input {
+            "X" => Ok(Self::Lose),
+            "Y" => Ok(Self::Draw),
+            "Z" => Ok(Self::Win),
+            _   => Err(Error::InvalidOutcome)
+        }
+    }
+}
+
+fn play(player: Move, opponent: Move) -> Outcome {
+    if player.beats() == opponent {
+        Outcome::Win
+    } else if player == opponent {
+        Outcome::Draw
+    } else {
+        Outcome::Lose
+    }
+}
+
+/// decrypt a rock-paper-scissors strategy guide, run through it and calculate the outcome
+pub fn part_1(input: &str) -> u64 {
+    let mut score = 0;
+    let throws = input.lines();
+
+    for throw in throws {
+        let mut throw: Vec<&str> = throw.split_whitespace().take(2).collect();
+        let player   = Move::from_str(throw.pop().unwrap()).unwrap();
+        let opponent = Move::from_str(throw.pop().unwrap()).unwrap();
+
+        score += player.score();
+
+        match play(player, opponent) {
+            Outcome::Win => {
+                score += 6;
+            }
+            Outcome::Draw => {
+                score += 3;
+            }
+            Outcome::Lose => {}
+        }
+    }
+
+    score
+}
+
+/// decrypt a rock-paper-scissors strategy guide, run through it and calculate the outcome
+pub fn part_2(input: &str) -> u64 {
+    let mut score = 0;
+    let throws = input.lines();
+
+    for throw in throws {
+        let mut throw: Vec<&str> = throw.split_whitespace().take(2).collect();
+
+        let outcome= Outcome::from_str(throw.pop().unwrap()).unwrap();
+        let opponent = Move::from_str(throw.pop().unwrap()).unwrap();
+
+        let player = match outcome {
+            Outcome::Win  => opponent.is_beaten_by(),
+            Outcome::Draw => opponent.clone(),
+            Outcome::Lose => opponent.beats(),
+        };
+
+        score += player.score();
+
+        match play(player, opponent) {
+            Outcome::Win => {
+                score += 6;
+            }
+            Outcome::Draw => {
+                score += 3;
+            }
+            Outcome::Lose => {}
+        }
+    }
+
+    score
+}

src/day_3.rs

@@ -0,0 +1,32 @@
+
+pub fn part_1(input: &str) -> u64 {
+    let mut priorities_sum: u64 = 0;
+    let backpacks = input.lines();
+
+    for backpack in backpacks {
+        // todo this should be .chars() or something
+        let items: Vec<&str> = backpack.split("").collect();
+        let items_per_compartment = items.len() / 2;
+        let first_compartment = &items[1..items_per_compartment];
+        let second_compartment= &items[items_per_compartment..(items.len() - 1)];
+
+        for item in first_compartment {
+            if second_compartment.contains(item) {
+                let mut byte = item.as_bytes()[0] as u64;
+
+                // this is kind of diabolical
+                if item.to_string() == item.to_uppercase() {
+                    byte -= 38;
+                } else {
+                    byte -= 96;
+                }
+
+                priorities_sum += byte;
+
+                break;
+            }
+        }
+    }
+
+    priorities_sum
+}

src/main.rs

@@ -1,7 +1,11 @@
 mod day_1;
+mod day_2;
+mod day_3;
 
 fn main() {
-    let day_1_input = std::fs::read_to_string("input/day_1.txt").unwrap();
+    println!("Day 1, part 1: {}", day_1::part_1(include_str!("../input/day_1.txt")));
-    println!("Day 1, part 1: {}",   day_1::part_1(&day_1_input));
+    println!("Day 1, part 2: {}", day_1::part_2(include_str!("../input/day_1.txt")));
-    println!("Day 1, part 2: {:?}", day_1::part_2(&day_1_input));
+    println!("Day 2, part 1: {}", day_2::part_1(include_str!("../input/day_2.txt")));
+    println!("Day 2, part 2: {}", day_2::part_2(include_str!("../input/day_2.txt")));
+    println!("Day 3, part 1: {}", day_3::part_1(include_str!("../input/day_3.txt")));
 }