day 3 finished

inputs/day3.txt

@@ -0,0 +1,300 @@
+lflZfgnSnlmmlgGfjGthQPtLNsQhvbHLLpSS
+zrCVDVFMJTCTcCJMwCThWbtbpbWpPbtbHPLQssLsHP
+rBFcrwFzFwwVDcDrzTzJfnRGjllBdGZnnZfhqmdn
+FjpnFRDmbRtnbJrFJmSTsGShWVhGqGVVsmqs
+ZwPvNPdzNZwfzBNLdNNNNcLvhnQhqMTVsTGSWSqGqTdVWhMT
+vgLZHfvLffNLPbggnrbFpJnCbC
+hzJzGjGfqmGtDQtDSvVV
+plpcMBNBcCTlTgCMbvtrsSVsVJDJlrwDQr
+McHBMMcTTHgJnWqnRqjzZnnRzR
+ppvsGZhDGprrSjSllwfZ
+TTFMMFJMgMHmHmdqdSvNqlSSSNJv
+mgBPHTRWFRVcpvsVttppbv
+ZZDssfMDMtqqppZLLJzmzSTwNJplTSgpgm
+BdCRRHFRbccWWBvBHCdcJVngNVSvTgVNzgNNVmnz
+QHFFrBdcGtqPmmQh
+qLvQFRgLSSNgqQvRrqLTQvLttwDBFWDwjwFttDdlBBwBwM
+nbsmZnbmHbZVCGPVmHWtwlStBDtwBMtwWHMj
+CnCbhGCPpPCSnZmrgRNRqNRrLNgrzh
+vgLWWHRNLnWwLggWzwLFFzMmBMRMhMhTbhsmmsbbmQTm
+rScpJJDDpjtSDPPPJDpjqPCHBBtlTdblmmlhBsMMmTsbmtsl
+GHZHCPprSSwgvWNVwVZv
+dMrCMJMqvtdFwcjczjQzThtm
+gGbLblLpZlHvllQhlQwcjT
+GHRWvPRbPHPRvNGbvdRBqdqBBfRqBqnrfF
+VsHcljlbhmHbHHlcjVcVShJSCdJCfMrMMQDfRNFCfMRGfNrQ
+tGtvLtpgBTGvDMMRdMMgdCNM
+pnGnGqGtvtzTLjWqmSSjHhWhWs
+NJTDntDNDVjNnjBfjjjcCZCZcVqCSCLqcSScCc
+zvhgRgQvvdllgQbHghlvHrRHSScBCRqqwCLGqSMCZCGGGqMZ
+pvvrHzdgvlgzQphQsDFmnsNTTtjfjJJmPB
+ScnSZSZZlmjmHjjWHHWZftJVJpppwtVVnLJtnptnwt
+CFFlQBbbPQqrBwJrJJrGJD
+PgTqRddFzgdRPFFbFgqQFgsSjfHWfSHmSMWcjZlmZmjTZM
+lzBRtctbnBRBRBBWnDnDWjlLVvwGMrvwrHHQHGmDvHQvHGrV
+FsTgFCTSgsCNspzhCGMfTHQVwVMfMmMmrH
+hSdSFgghhqpRbLqjntqnPz
+DCDnNGFFDQdQmVDNdFVNFccpJLHWSvPLrvvvPtGGhSttLv
+sBgTzzZqrBlfljslWBhvHSvPBhSBJSSL
+lRlTgMzlzrwRrnmbCMCFnNVMnc
+MJQJMJHBrsdrHwts
+dbbSVGgbjVqGTVfqddCTpmWWcprgNgWmcWwWswpN
+LPdGGdVGPCVdLBlBMlDRRRMD
+vdcwZLTdTFFRDHVgmpppMmqZ
+jGPzCnQPjlsDVqDpqDHbgP
+BjWJrlGQQzrCzBzlzBCGBznzwNRNcwLJdwTJFTHRSTvtLcNN
+ngrgqTjJJZnjFJpnqnnVTLzBbbHbLQdLHLHbrdHdHG
+lNcltCCtvftfWssPbMQdMBzhbbcBDLdh
+PRtWsQCmWsmSsCNCSvCSWlspwgqjqmqjTpnJZwnZVpFwgq
+PjWjGDCjmrmWPNmvWDWFmgCNfVJRLfJRfLDLJQlfHplpRbfR
+MtZMtcSbccZshTtQTVVTpzHlLRRQLV
+cZhbwMnwqsqnhnqtMBnvNFrnGPNPPmgPGCgW
+WBjWjWjqZwQJnJZCZZbf
+StHSDRPHHcTrTrJpLCCMbrqnJn
+RvTTvGqcqTFvSvSRDHvRjlhgWBWBdhjwjGgNjhlj
+FSbCqcFsbCPtrcrqhCScbshMjHDGGWBLHBnjGLPBHGGBGnHj
+flQdlsgQgGnQHBHjDn
+vllgRZdmvsvpgdwZgzJdwRmprqccSFcSShJbTSttqMCrCCch
+GwwgCtvHgwcHVVDqpWdfnqVv
+sllBsSNBjSrLfqhLgjfqhL
+ZbQbZQzgQQPSblBggNQRHGZHHCmwmHFGGcwtJm
+CmGVGBTVTmmTWTNLLCVgCSFvDQppQQDDnDQDJpMggfnQft
+RrtdqtldPbHzRbnjRfQZjJfMDnMj
+wcwhccqrdrrlFmLGCwCtSwtL
+pzZznZphZnpcNWSwGwVVPzrPrG
+lgFllLLltgbDsrBCwrjWGmwmtw
+MgJbDLlMQRJccchrhc
+wbbjzZhdGDwLzZSBWqqHmZgssCWqFtMZ
+VRJccfvPlTTlQlHQCWQhMMhCCHqQ
+RlVfVJcPTVTfvvvJfNJVlcBjGjwhSLdBNGGnjLLBwzGb
+bvpqHMVTTpZnqnWRQQQw
+tfhFFdSFggfhbldhhZcnRscRcQmnRs
+DPzgFJzFLfFbFSgPFgdPglMHpvBpHTCMGpjvMMpLvvNG
+JggGLQgQpLpSPRJgGPSnGlFTDBjjRFvRjtBFjWvFjqRj
+cmHhZcMHcWjrTBjrvm
+dbHwdNNHhwTNThZHdlwQJJwngpgnJGnSPw
+DbZjVfjVLhZDLpWPHpMZPmmGNp
+lFcJJGcFqnBFqwJCHHMmNHPsdCNp
+BlwccRQtBwBrwLGbGhGggzLgzR
+RBhZPjlWqgbNbgGLBr
+MzSmSzpFdHwpswzzHnzjnvLCbgtrtLGLbJLLJNtJtbwJ
+MsSHdmMdpFfmFjpfcPWRhRVZfWQThZ
+mqmssPCFhhsJccVg
+FTttfwdjjHznJgfngpnc
+dNFTjQNRtRNQldRNrRdHMRrlPZqCGlGBCqqZmmbPqDmDCmGW
+ZJVRRZZJRcvmPhCJrvhm
+PPWQDTfWbnnstlCGvjGrWMGMvr
+TbbwddndsnsfDpwFqZFVHBVPqc
+tFmpJmgJJgmFDWgRgFrrlGSltSQvZChMtCMM
+TLcZHsjLVNBwGQCCGlsCShvh
+nqNdwwccBwVLwjjDznZzppbgzFZfDF
+qsTqCCCszjlqTssBShlQSSZFgZZhgB
+LDPmVgDDJdLPrPgLgPZSFZQfhQGGBQJcSFJS
+mvmVbVvtggVtvgdLVvtmptCsNTtjRnpRTTjpsqCp
+BdNPLnmFvLFNgnmBmnFGnwSZZZWwqWgqjwWssTHWSS
+bJhMzhbVMbDCcVpZtjHMqTMwtttSjH
+hzclfCppVqQfbzQVbpzPQLNFBdrvdNGGBnmrmP
+nLVLzBDJCCHqdLncqVJgSsDlGsbssmvvvbvbff
+jMNHFWNTZZNwMPrPWrrPMMrrvSllbgsllfgbgvQsvGmglZbv
+RjPjrjRPtNrwHhBtncCJtJtL
+jbhhjhNjvqNbmjMjqhtCFdmPFdlzJzfFfJQJfR
+GBBZWrZWgpSsnSngrrSgHzFzFFdClzfFQFlRZftQPR
+TrGTrGWHpHWGHWVWsngprHpLbLLVvcqMcNbVNLhwVNbtNb
+sQDvDmDLQFDRsdchzhBczLhhPhVz
+MbGGMjjGZSjvfHvHSbfwBqcPnqqcPVhPNnqnzjcn
+ZwMMHrWvSHbfJfTrbJwSMMfMsQDtsFRptlpdCRpWmptQDRmC
+TwMHdcTznLqzTrHdzzzHTdgMRQWRhJhNjjvgQvQQWNjl
+tbfsVbDCVSSDtSPQJWPvRNhQtghN
+FVGBpGCVFCbfCbVbZCSHqmwqcqLcdHJGwHqqTd
+lTlGfjLGwHNMggscsDRwsC
+MrFtrzZZPZrtVQtnrrFdQhhDPDSphgDRhDcsCCgWpW
+ZJmJVzVVJFHfGbqJGMLv
+zsFZVjzlHPfTzGfLGt
+mdrrmdMMcBcmNqNbPqfRDLPWPlqTWD
+BNQhmmrBrQghgSmNBQQSmvwssjZZSJHljJFFHZJvZV
+rLZCsZdMJfdNCsfZMrLdFmssnwgTRQgBBwgRwcngTNVRVQjV
+StqDHlStDPgRTqcwjT
+GlDGDhbpHhvSHWlzbWlhpzhJdrFLrCLmvdmFZsmJJjJfdv
+pJHJMJsJjSMFdHhszFvMhlmmGNlSmmBGllWmVlwcTw
+ZqZRDrZCZDtPDPDrCngrnnPQGVmGHVBWGWtGmWVwVlmTlGNl
+ZQPgRqrrQPqLnrLMvLphHdvdjpJddb
+NwbBjljFbcjtTcccqW
+RHZrPHPpNgZTzTqc
+sfrPdmPdpsmPPPrfQPVGlwGVBwbGVnFlNQCG
+hQdNTlzhdTvrhdnTBqcWBLsBHgWQgBPg
+zwzRDbDfqZBLHDLB
+wFbFmjjRzfmjGGMGMfmJwwGCCnvNhpvSCNnrvJvCprnnSp
+zshNNJbwGFJfGJzzzNRnHGnCnRHcRPgTmPmn
+LMDVtZLStrrZClBrVDllLSBWRPTPPRRPmgWPVmPTPHTWgR
+SDSqLMlrtLlLtrBqBdlMZjvffCNzwvhjvvzhdfNhvf
+SLQmGBmhLSLQTBGBGwdwpJjwwQjwcVpJZJ
+sNrWrWPNbHghrbgnNNzbWbFWdZpMpzVpdMZMzMMVZcwwJdwd
+frrPNNWshWhhHDvDGDRSBSRvttqv
+FJqpgvhJJRjFjZTqDsMHrzwjsSsSszMrMm
+PPPQWGtnbbfBmPsFswwsMrcc
+QfBtbldtWQfbWbnfGlFqZppvpFZZLhFlpq
+ZqSMZHHCMpHTZTWmFTFZPZQJBgVGVJQvVVSDBvBtcBBG
+RNsndwsNjsbsgGCgjQBttcBg
+NRszRRNzLNNNwNfhCCrfdmTqFZllFFHFFpWhlTmWpq
+llbbzDmSspGRpHpzsldzRRsVtFBBFJMMVVFLTTTMVtLTDM
+cqgjqvNgvqCjQZqgGGnhMTnMJVLBLMtFhhVFWB
+PfGGvQrPCjvjZgGCCCZZZbSmmmHlRpprlHrHwssSRr
+mRmpFpWpfMMgLnmS
+CdCsqzdRzqStLjSqfMnL
+wQRHdTzCQbzCwsTrZBlFZGpVlpFGQD
+qnMTnTVSTPTHTHcMZMvVpmppmFmVzFLLFLlFpG
+gBjDsjRRwhDDghthwwWZwLmpmwWWLWLbGZ
+NhZtZtBgPTNJJNTS
+jLjjmpHvzvZrfzQjmfHHWrfbqblLsSlTsqsgqPJbPqVglb
+FBcCwDwtwgcgnCwcGchtJSsRqVRVJPPqDlbSDRPq
+MBhthFNtMGCwhcwnpQfWjNrQprpvzpgQ
+RfCnWfnhCbwHgWjzBgzB
+PsVqDsSTshsgszpsph
+DPDvTVtTShhSZhmqSvLlQJFnQJJZnbCnlCCZ
+pRRdJngltnwwvTNSWqWffqgBqD
+HQGcsdrjzMDDBfGMGG
+FLhsdbzCLLHjhntpVnRPRvZV
+gZNwQHHNRlGvhvhGRvRb
+dpSSBDrzdCfcSzfrzZrfCfMbthWWWPttDthvMFWvvvPj
+ZdpBpZCrssBJZfSJBzBdCTcnmQwmnVVlmqTQTTQlHLwNnN
+ssCpTttVVVpzZDVvRpCsRtDgWBWBBFBJvvJHMBghGghrMJ
+lwLmNNLwSblbmSQLfhJHZgHrHhhJJhHHmW
+QLSdbdPqndlNlLdSLNQncpRtRTcRVTPPZRCjVCcc
+wzzJclzcTThvWSSCqRlQSsNN
+rDpVjpVVDpsQSRDRfQmm
+GLbjrLpFbgLVLLgdbjVpchcFZhvBwJvtvtJcZwRB
+wPgZgLVMfWVTgmTZZZftJjtfjtJCcdpjdCqc
+zGGbQQnQGvBBhGQvvvBBSBvQdhdqqCpdddDmJlCcDjCtJdmJ
+HszzHBzQBSmGSwTWgswZPWTVgZ
+GDFvzCFdrszSdNJrFfjjfqZjRfsjpqmcwZ
+WbbVtVnBPWMgBLMBnQQnBQHcjfjpZRwqcwMfcNTZRqqNmT
+WQQnVVPHtggLghWWhHnPVQbvlJhSlrvJDlFGJDdDCzGNFF
+dVhTBjBHtTVqWRJZRqhJZQ
+brSDTbDfcCwDzfCSbwMQnlqCRJnMgWWnZngM
+DFwNSrwNwbDzbFTTFtjmBpVdGpHs
+dPQfdfTzDrFDmFDBgBFj
+RlJRclcswJRvnwPcpjbjbbCZjFjbBmsbFZ
+pqncGlcRJpHGpllGHhvPhRTHrQrttVVfrdQzfrTdftfV
+RCzTzRMTfCfRRDzRfhSmZZlCslBbZZBVtZBZsqBL
+nvvJPpdcFnPcWnFnVZvBqVlZMbZBNVlV
+FpWPMdjdPhSTmwfSjD
+NDJjNHLLNWjcLLWCLJLZjLDtRqqtgtMqgtqnRqnSRgggtZ
+BwrlfFwmQwhwfPBFhsBdFmbQggCgqQVtbRSqttqMngnp
+llPPwsPlGshBJGWJLcHvCzNv
+rBvTmwdTSbnrvVWsWVftGfJQGT
+gNRLLjlPRWnFVRFDFW
+lpCpPNZqZCdvdppnSnBr
+ShRdCrJgHClZJtZDGMMz
+LvqVVTTNbVPLQNFTnwwMtzFZGDDwmtnM
+VLbNvpPvTNVqVbbNpbVPGNLPrRWrcRCWdSrCjWSHcHSdWpCh
+tNmZnLSZPFLDnLTmhJMWczQdhmWhWH
+bGqbgrpsCsWhcChNQfJz
+vwlNbppsRGRRSSSDvjTjLZjZ
+zgMZhgfBtftSZQQmLHpSWH
+cdqcqnrJVGjjqPVjrPnfpJmsQHQQpsSsbsSDmm
+NNnrNqNlrNcPTlBvBvgggfMv
+llPrrLHBHCrRRBjrHCjBdrPmvJZzZgZbmgJlZmZhMhhmvh
+pNDstVtNtGFNSDFScQtfwzzFJwmJhgqzbMwqZJmh
+fpNsptGtQcTsSTccprddCWPrWdTRBMMCMd
+TTtDVqTsTcJFgbCqmbCq
+NWZQnllzfBFZPBGWQGzFPFRNNgHbHrrwbNrmCbggJRHR
+nBZjGFjMQBMPZnjfWjstpcctttvVtcTttMpL
+qphVCCwnHqhnRVznFwvLtBTLDTWZtwLWWS
+JmdlsdlsjfJfrtjTcvtctDZSSB
+rsmfPGbrPbPJfPmrsgMrdJdlFTHhFCqhNqVHnNHHCFznhphG
+JsWFMJJzrhSSdFdldmmdmdQc
+qLLgCVTgLbBvqsQPVdQGcRRmQmdc
+bBCBgCCDbLDqTvqqjpShHfzrzMfjtHHSHsfz
+nvFSBFlvvgQFFBzQnlQglmRRzqwsrrMJJMrsMqrfrwzf
+CjZNCNhLDNbPZZLZZhwVjpcfrqRhsdJqdsshRTTdqJrJ
+jNNDDppjpjDWNVLCVVDpGVVPBFtlSQFWvvQvSSQHSgwQnvtB
+WhrQWBRWwhzgmpnSpH
+LqMVsJVvFMJLJMsfNjsTJvCgFbSmzgpSHzmngHbGPCbm
+jvMjjtqVjTRnwZQwBWwt
+jfTWSGSTTWhgcngQfbtJfNzztBQBzz
+pVVwsdppRVPLVmPsVVHsjPLPzQdzBzQFzFBNNrJZZQBzbbFF
+VmsqHmjHmpvGDSWDvlclSl
+PNZfTFSFfTFGCHqqmbFm
+WjzRWrjVgnjzplrWWjJVppgGPGsgstmPCCtcmssQqGQt
+pzjzJVvnzJjWvpPlnVRVrvnlTDLNNhwfdNZLfMZLwLhTNvTw
+QFrQZMFVrVpVszzcNTdMRCCb
+SvljGmlvLfwLhLLLHlHdNzsRthhbbRccRCRNbC
+LfwlDmlvGBSjjlLLgpPpFJqgQndQgZBJ
+RBjPRHdjPfqQcfhcdv
+SngFcJZJlcnctSlhhsQvGsDGDsDnfs
+pSmFgSWNJFNtStrmNtpCCjPVcbjjHbcWTBHBHL
+vGjqCPqNPGFGNftLwmZwfQNTLp
+hrdBCSHcCJJcCBShJswmLQpLbbQZTLLJmmZp
+BdHHSzrBWdzchzzCcdzHddcDVWFnjPjllGggVlWljPFFFWPM
+hBtZZnpbhbPZJbnhDtPnpBtpfjfNNzrrCzjFzFzFTjfjjWzJ
+gHllMqRSmqcqMTdggMqHlcFzRrFQWNfvrRvzQrWjWvWf
+gwqlgHmmdsgwlwMHZtpsbBbtDBThbBht
+CsDLFFLFCvczsCsJrCrJJLRgbQQgmMmPbDDQbPnMgMmg
+VlwNBNVhjNVNWBwWjtbRMRZzPmQnfQMPnlZP
+VWWSSwGTwtwWWNVwwpqJJrcJGvzqCJCqJF
+wLwSSbzwCvddlvvlSj
+THnQnnHttcvpQzrZRllZ
+sTntBHTnVbPbgzsbgL
+FwHgrHvFQQwpHhNhTBLdpNNNLd
+fCGqCVtszfSslCSzSGsfCssjNTqLTdmjNLBLdnTTTMTjTg
+DccfslfgRSSVVzlcSVtzDRVHwQZFrwwvwFWbbbRRWwrFJb
+CwwWwwFNRpFFpZQHtsmfqbQDTQTTqb
+VcjzLjGjzGjGjVjLdzqmDqHrsmsqGRrHqGqH
+RjdVlgdnljlBnSgPCpNwwMWwMM
+tCCtqtbPGzsSQVzQTq
+mzMmHMpRsRQTsFFV
+DpzDwgdMzMLppNmNpDpfgrbhLcGtPrbtrbrbhnbBcC
+BvsQBBBLvDQGjDvSQLTvrHprHlRpVlVllgRbRbHPqq
+MMMMCpfJFZZMmCzwpVPCWRtHgqWgqClgtt
+FwzmfzhFFdFcpvSDSBDThs
+fQrGQbFFFrHHtlHPclzzPLvc
+mTnwpNCCqMqjmCThpTpSvvtBczstlLznvsztsPPP
+mCpTNhmmpCqCmjmpTjmLCpSJQZVfFVrDVfffFFgfgJQFdbgG
+GmWjRBSfttcGfRcSclVVJqsTMllsgJVMVZwV
+pPFNpfNCdNzCVMTTNqVssqJN
+dzPfHCLLhdjjLGRnmnmr
+GPhPfGWgggfslffPsVPGsqJMzLQJtBprwQJJGQwLpQrw
+ZNdmvbDDbNvHbmZCcJQwMmzMwWWQrrwttp
+bvdDNdnvNbnHDdnDHHRSbnqhqhWfjWFVTVhRVjfjFTfP
+hTThfWNCDRfsVCDhpgzgbpPZZwbnZQns
+GSjGGcCBGmdjdSlGBcmZwzJzpPpJzwPwQbzgPd
+BGmcrcStcMMMmrSLmSMCvFVRFDhfFhhNDWWTqFqTvf
+ZmjDTTbmqQCCQQSwvhsL
+FGVJPmPmtRVRsCvvRLwwhC
+JgdHJgmfbjzTpTMf
+fTbsVCsssgLNrfNrgm
+zQvzZlRvddvpNLpZrMNNLZ
+HLvWFHHlFQvzHnnlnvQqhzWvstBwbGVtstjGqjjwqGGCcwGq
+JNpNdzzdJhNnfNGBZLqZqlhvSZSG
+QswtcmmwwmTmwwcwZSLlZLDSvSvlBZQD
+FsVFBbFgFsPwtVBTwgTPcsmpzdNngfzfpCzJdzCJzNCndn
+qcvrLBppgpWWWgLcpzPfhNDqdzqwDDzwhV
+MZFjFnHFMHbMntMtnwStfddPhDffDfzDfS
+QmnjMZnlHjmnMGFnFlMmjlZWzLgsGgcrspBBLCBcgvgBRC
+sdfWHjZfrZrSPMCQ
+zqtWRDDDRMbrQJPQ
+zwhwzmqwzmFpWzvFqBmFvjNHlHfgVLBgdfVfNVjLsl
+lRlBTlvlZfhtbGBWtFBz
+cqCNjjqjrNrcNjwDqNPCVrSQStSWshFhtQhbQzGzmFCG
+HjPPzMcdNqjcNHMqPjdpgpZflfdgnTfdlvlJ
+VpwQJVRtHplnnwtppHhqWBCfVdNNPqPBPWsBDq
+jzLZCrvvrZjZvqNffvDNDcWDWd
+LTrZZLFZbgTzgjZZjFClJhTHTplQpmnQlpmpQR
+JGJnSWLGSpWHVHwGGJHpZdwPdTTPMdTMDdlzccPMPv
+gqrrmtbrbgggqgBtqmRSrFgNCzvMDvlMPDdddvzBcPMMMDBd
+gjrmRgmtRggFtqjbhgbjrtnJJHWLHQWZZLhZsLLGHhSL
+BtTDNggLRPdWQHqggg
+wrVpVVlCJVGMMJVdHWSdPSqqRwSQSP
+vCVrpvvGjlphBRmZBhmBhBND
+lqDcZGcSSqSqbDnccSLJgHgLRfnvvJRLmvWJ
+FVCFPChQzVhmsFBgddRgJBfdNfJdfv
+FzCpmTQzjQCThppTSttqDccMTDGcDG
+QCSGBGCrCsMBTCQwMGSfvvLNNnnVLDlNVNDdVdlr
+ZHtPffjWbqgtmnNdvljFnFhdVv
+JRWbmgmRJtmJMGGwSBBRRRfQ
+LqNrCfCQQhtgnPnc
+JWBrWrVlbWgbbtcb
+VwvTBprdrVJVNLNMNNqfqpjN
+bjVqdHrdqVHPsPNbqHbqNdjFGRwRGlttRtMtRtFFGMLHJw
+cfSpZnBZWQBZJlGRJJcwGMGL
+WWBhTMgDTZghVjgjssbrbddd

src/day3.rs

@@ -0,0 +1,111 @@
+use itertools::Itertools;
+use std::collections::HashMap;
+use std::collections::HashSet;
+use std::fs;
+
+pub fn run() {
+    println!("Day 3:");
+    let input = fs::read_to_string("./inputs/day3.txt").expect("Could not read file");
+
+    println!("\tPart 1: {}", part1(&input));
+    println!("\tPart 2: {}", part2(&input));
+}
+
+fn part1(input: &str) -> usize {
+    let mut alphabet_map = HashMap::new();
+    let alph = "abcdefghijklmnopqrstuvwxyz";
+    for (value, letter) in format!("{}{}", alph, alph.to_uppercase())
+        .chars()
+        .enumerate()
+    {
+        alphabet_map.insert(letter, value + 1);
+    }
+
+    input
+        .split_whitespace()
+        .map(|line| {
+            let (left, right) = line.split_at(line.len() / 2);
+            assert!(left.len() == right.len());
+
+            let bag_intersection = left
+                .chars()
+                .collect::<HashSet<char>>()
+                .intersection(&right.chars().collect::<HashSet<char>>())
+                .collect::<HashSet<&char>>()
+                .into_iter()
+                .copied()
+                .collect::<Vec<char>>();
+
+            assert!(bag_intersection.len() == 1);
+
+            alphabet_map.get(&bag_intersection[0]).unwrap()
+        })
+        .sum()
+}
+fn part2(input: &str) -> usize {
+    let mut alphabet_map = HashMap::new();
+    let alph = "abcdefghijklmnopqrstuvwxyz";
+    for (value, letter) in format!("{}{}", alph, alph.to_uppercase())
+        .chars()
+        .enumerate()
+    {
+        alphabet_map.insert(letter, value + 1);
+    }
+
+    input
+        .split_whitespace()
+        .collect::<Vec<&str>>()
+        .into_iter()
+        .tuples()
+        .map(|line| {
+            let (left, mid, right) = line;
+
+            let bag_intersection = left
+                .chars()
+                .collect::<HashSet<char>>()
+                .intersection(&right.chars().collect::<HashSet<char>>())
+                .collect::<HashSet<&char>>()
+                .into_iter()
+                .copied()
+                .collect::<HashSet<char>>()
+                .intersection(&mid.chars().collect::<HashSet<char>>())
+                .collect::<HashSet<&char>>()
+                .into_iter()
+                .copied()
+                .collect::<Vec<char>>();
+
+            assert!(bag_intersection.len() == 1);
+
+            alphabet_map.get(&bag_intersection[0]).unwrap()
+        })
+        .sum()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let input = "vJrwpWtwJgWrhcsFMMfFFhFp
+jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL
+PmmdzqPrVvPwwTWBwg
+wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn
+ttgJtRGJQctTZtZT
+CrZsJsPPZsGzwwsLwLmpwMDw";
+
+        assert_eq!(part1(input), 157);
+    }
+
+    #[test]
+    fn test_2() {
+        let input = "vJrwpWtwJgWrhcsFMMfFFhFp
+jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL
+PmmdzqPrVvPwwTWBwg
+wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn
+ttgJtRGJQctTZtZT
+CrZsJsPPZsGzwwsLwLmpwMDw";
+
+        assert_eq!(part2(input), 70);
+    }
+}

src/main.rs

@@ -1,7 +1,9 @@
 mod day1;
 mod day2;
+mod day3;
 fn main() {
     println!("Running Advent of Code 2022");
     day1::run();
     day2::run();
+    day3::run();
 }