day03 part 1 done, part 2 wip, wrong approach

day03/Cargo.lock

@@ -0,0 +1,25 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "day03"
+version = "0.1.0"
+dependencies = [
+ "itertools",
+]
+
+[[package]]
+name = "either"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]

day03/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "day03"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+itertools = "0.10.5"

day03/exampleInput.txt

@@ -0,0 +1,6 @@
+vJrwpWtwJgWrhcsFMMfFFhFp
+jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL
+PmmdzqPrVvPwwTWBwg
+wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn
+ttgJtRGJQctTZtZT
+CrZsJsPPZsGzwwsLwLmpwMDw

day03/input.txt

@@ -0,0 +1,300 @@
+vvMQnwwvrwWNfrtZJfppmSfJSmSg
+BzGqjlBqBBmztHNFzDHg
+llRCPlTPPqBjPhqhlBRBClhqWcTWrWNcMbQbdrdLccccrnvM
+wMhwbTWpQjbpWHMQppzTHhjtlCjPSSJCCtlqRlJVFJFt
+ggdvvnvDgdDmNcBrrcDntFRFqHJJtSJqvlVSRlJq
+fggNNffGmcBrmBfcDzzzpHbsGTpszwwTbp
+BPdPPBggrPtrpbtvPBBdgrFmhhQThGGlbbTZnzZQzZfn
+ccjWRJVNcTGmnWWFmh
+DMNmsMHwRNBrggdPDPdt
+TfsfHLQbBtBFQbQsBmPwwlnPGZFwwdwWFZZw
+MRpcvJMJVSMrVMpVSvhhnclwgWwDZgWgWgWglwcG
+GCzjRJjVjSSrvfNQtLmQNsQbjB
+FrSPFjtVvwsqSwcG
+hDHdWDngpgZTDgHzzHwNNqlwNvZJlGqcQGsl
+wDzLTDHgFffLtRft
+CnCJNVqvCBJBNZmfPcPMcFLVcwmd
+HgzjHFghSFtrLfwPchPM
+QDpjgDSQlHHlDQQRzRzsBRRvWnWvJvZnqWBJNF
+mGHcFPFqzPtcfPwDGVVpgLgSlgBl
+rCvddTrnsbDLVSDwjSjd
+QWhWQThswssMQMMMvhTzPqJzmzftHccJfHFhFm
+cPbNpLVFTPbbFrpTLQBzqqmgnnBhgLMM
+vvSwWCZCRZCDZtGwzdgWdQmzqgnQddJn
+vCltGltCGmRRmCvDjjtHFpbcFfbbfssbpNPpHFpH
+WLLQMWZLSPMPWmrwhnjhZZhpHJHljBDB
+csbtCfFgCftGljHwHcBnpnJR
+tsvgszNtfMwPzWqPrS
+NbDZrbrFQQqqQtQqQDtTcBvCLBLswsZhscCGBZ
+ljmWRzVRpbndMWmmfdsTsCBsGwTVVVCGCGws
+ffRpnllHRMfdWzdnmRNQNNSFQQFNbrFHHrNH
+LccGzWNjcvNLGTmHNsNLMlMwMpMPGlMCwFwDDGCw
+fZZtfrZgrfQSnnnSnJRCglHpCwwHwpglDClFMw
+SqJQnffJRnfQQVRhrQtrhnThcLhzNzHdTjhsTWzjdmcm
+QJQwJMSbtbRgMQMQVZpCZsrrhpZBwrLLvs
+qCNPGWdqhpphsWrB
+DcNPNnqjdGDqjmPGGJRFMQmgtlQmQJCSgb
+blTRbDnHRGGBwnGPCtFPWzVCDvFWtL
+pdSJprqhhZSdqSdZNhVzZWtzLVgVPvzjLzWv
+rrsqsmrMpPHlwTsRHn
+mbNhgbRSLmTwswFm
+vHjHBWMHBzMqWZVZBzHzcwwwdcFLcpLspdzwpwQd
+HfMWMfvjWtZHqWDlhSnnnJNnbhslDb
+lwsvPPnqlwwwsPcHTgqcRcSccmgQ
+CVWBWCFpFzWfFjWjhNSQJJmcVcHRZJNTSc
+zdhfzBtfLLtfFClbrDvsPvtPbnmv
+PntVQbDnQHcDVvhtbtDhcbPcFTrrNfjqmmPTTZqMLZZMjFZm
+lgJCpCFCSCGCpllWMfZqTNNZrMjrJTTM
+CSzSwgFlzsGBzQcQhsnnDbVdtc
+THzqvrVrWzhqhWwqhTbNNDRtFRmmpFDDVsFLLsdddF
+MbZSSScZSGCJCjZlCjdPmpRmFLDtctdmFRsp
+GfJQlnZjSMnllbJCQbClnZQrhNwwqhBzTNhrffqhqWhTqz
+BdBdmDZHFFbrHHStPSRtPCzSRNDS
+JGGpwqLJGMTLpLlMpqLhJtzCCSGQSPzNNczVVPVzSV
+WwpllfslqfhffLwhfJpJlqlwdBmZnrdFHBFBBmNHFsFmdZmn
+jZfQZnZfnbRfjCnfbSSmVpqmNmVpCqlhCqqPpP
+MdJMwMvvLDssLtFMsMtLDsvvDRmmmPhWzWzphpmqDVzPDWNp
+TsLdMrvRtLJtGdtGRRtFTBjSBrScnSZjnbcgQgHfnB
+RZfmlRlWJmWLLRscrslJqvvMdVwmddvPddQPVDdDwz
+GStFbFCbntbjNnjFhFvdHfhzHfzzQdMHwPdD
+BSGpFbbjbNjnNNFSbRsLlWqgrZrfRgsBlg
+ztHczmrmcNNzHsPSTwsPHSQPQT
+CFCRjlvbClCjBdPDFQdwBsqn
+llbRgjClJCVVMMCssfmNZWszrNgzGL
+mmFldllVlmtdWFvPPFBcSSBW
+DZzZGzZswQZHwQZjZzWWTSSvjSdvPvvWjJTS
+DpQQggwzZGdmbCldgVgf
+PJJvhqzVGbTFqzqbbGTlLmrtrZMnnZnntlJnrD
+fNwRcQBCRNddNgLtgDnttqrMMtlr
+RfRdNWQHcqHscdfRdGPFbFPpvpVWWzPzVS
+DRgjZRRDggTfjfRvwWzHGGHPWDswvv
+dhbmpcCmchgCpsGzWPdVGvWHwP
+hpMMMpCQMnChFgNRQffTRrSN
+gfqPCHWtPMMjCtffgjQWGLvGdZcdLLGZcLFGZBWG
+pJTDsnnnvBjnFwvj
+zJRpTbNrTSppRVblgbljMgMfCfbC
+fGrGwqggtbVmtzbf
+CTMjNQcJjJTBNCjMNZFNBcCZHbmWZHVLZDDWVtDzzbVmlV
+hMvTcNMFMhQjTTBFBNMhwpspwgnGtvtnSgdwrRpG
+RfFdqPdMMGPVgWmNVN
+QwrTsbnSsSQpwlSSbNNWDmGLVjjmLWwNVB
+rpcclTCprmZQSbprSTpRRRfqMfHHCHfhMhvFJM
+LnJJsMtLbzsPPVPJbrTBlTWlfRfqnTrrlr
+VDHVQNFGgNTrSjSBjq
+CHFHGmvDGdZZGCQZVDgDHVbwLLwtMwwmJLJbLPPMbczt
+qNNNBllFBzFjjzwGqGgLrWgrtQjdmmtQmQpp
+ZMHJCPhMZRsRCsCPsSJZLmQdQgrtQwQwQZwdWg
+CnMPbbRbsPhCnbfhMPRPllnFGqwTTFzTzNvBGBGc
+wZWlBFZQgBzTzpZwBlVpzWBWnNMmnMvMcMJMmLGnVmqLqGMq
+PdSDfJbCHsHHdJjsRRhjjPjmLqnnrLMLcrnLvdLMNccvGn
+tSJtSCtbJhDhtzlFQZlTZTFp
+TNqZDqmMDZNMFSGHjSGBRBdN
+CrrwVwsPjjBHddPf
+rpWggQVspQWcgtLwcHZZzDDMLDvvnnMzDM
+lWrWmPwmGlZwZjdLZLzV
+cFcDJhJnmqBqDCRpZzVLNsFLjLzdds
+qJchTDCBHDWglmrfWPHH
+RgLRnTJWnfHDcQQBfg
+bZpNwdwbdMvVPsHHJMQfSSfP
+mVbdNNdrbCzZbdZvbWTGrhqjTJtRWttRjq
+TMtqqBJLrwqrZPlHHGhGnlBhzv
+bFgNcpDRnpgggjCzvWDWhQhQWQHHvz
+jnnVgjcgcTZMJqJVtT
+dVSjmdHrfGPddrQgstFgzsQfsMFQ
+hvJJCCJDcCtwBVFQzzBD
+RWCnTvWTLRnJJLJllWhTLSprVdNZVGHGNGGnrdGSZH
+gvMSHFZtBBMBMFZHzjnqLsLGMCzRWWMn
+QJmDrhbNDbJfPQhDmQPRLszRlnjCzzWqrRnlsL
+PcJVhJbJJNcNDmfDmjJmbhTfBvpwVSdggtgvgSFZwgvtgpdZ
+PBClRHHClRlFljllZSBBBllppVGDLpZVVVsGpmGcNDpGLL
+MvNwnbMwccVsswDG
+MqnNbzMMrQfnqtttqfQWQQnRdCSHgHPglRFBRWlHjWRlCW
+lldwdfSBWphHBggZghFs
+DjDbDVRzDmLRzRLGJjPssrLZPhdshFHrssTZ
+mvddMzvmmDDvvwQqWftCfqWqfM
+gpTTwNWGWMSMgJjnvpvvJbJppn
+lQvmLFdfrQzRFctlrLdRLVPnhPPbVDPDfjnVbfhJjV
+FLFqccvmmtcQtrmQccRFLlRLSSWBSgTWNwsggqMBsqWGHMNG
+PjPtVQrPVjrVPLLDQVFLTTWWqbSZwRwzqwSbSbbbwFSq
+lBnGJBnfflRRNZwbqb
+HJMGgmfpRMHGGdgncJHLDjjtVDQctLCvQCjTtr
+VvmvjRGwRwvhmhRvvvVCCTTJjfWqfDMMcJlcCD
+NpNbPfpSnngZbbLMFJWTMlLFqJJDMD
+bNSfdSHQZgVQzwhhvRmQ
+MhmHcDhChhcPVMDPDPQdFhQHnbNpZbZnprnrmNnjNbsllbnp
+WWqGCWSCzsGbbGNgjN
+LzwqBLSvwJCLPVMVDLdhMP
+mNVLLffSLVWdZCcFZCZrSbGr
+glvcwszTlsRDrHQCZFCvGH
+gTBRlJnwhzgTgsTnggslsJRTpLNmjmNNcdVLdhfpLpdLVmLc
+pCgfDrDrgccfppmDnhHMGqGbpHHSqzGLlqHS
+tFtjQRPFFZRVNRcQGbLzLFMSGzSbWLqH
+QRNTZjvjTTwtwNfmcTgfnCgnnBhm
+hcPBhqPzqWPccHWHHWqnPdssPVfFFmZDnVDDms
+NSLNCTRQZndRmDfnRD
+QSGTGbjTSTJHBlbZZBbh
+dgcWgVgWdvZSbbRtjLRZZZ
+MMDPPfTnPTQrFDMpHzmmLztLnsszRtwbtS
+rDfDqfHTpCSJqlCCGq
+bjsgllstBbpNpslBpdBgqljgGwzJzDzwLGGrwLQQdJDwGhQh
+nncmnmHHnmWRWmPfJCnvPRMrzvDhZZLGQwhDLhhMzZZZ
+mffccVHRRPTTNlpNbNjJVslJ
+DgPstgPtgPNNcjQQrtPJJCRSZTwSGJZZCZCJGD
+dHVvpzdBBhVqzWqvhvHdzGSZlTRCSRJrwSSCwJCWGT
+zpvVVqMBrzqrhFBvjbNPcPLnjcQtMcnj
+gBcmTCFghhCCBnBhWWwFbwLdwHFMLMdp
+LVzlZzPPMMzWWrwH
+ljqjsGlZPPqqlVsPqDVqjQQctNTnRcNLtCNmmnRTRthBGG
+LPRrrBNNjLBRJNdrGPRBfBrLwFqmDbdbTbTgmmgwmttFwtmH
+QQcVvnQphlWsCQCCVpnvptTJgbtqwHDwbJtJHFsTHw
+ppcJVQvpvMVMCvQZQVVZCCSRZPSjNRRZBPPPPzLjSLGf
+MLtRnjQsRMJcDQJnSrsfqVVvGwbbbqgggg
+WBFCNlFFFhFBlCHbplFWdpWZfVqPPwqTGdqTGvwrPVvTqvTr
+HClCHzFzFBhmnjtQzMMSMnbD
+sVnMCsdlMRcMFBGz
+JvwwgrJDfgDmmggQrhNfhQQftjFrGRRtZFGBRZFHzjGcjrcj
+PBJJvgDPNllPddVCPl
+fmmRSnfnMnFSmMmmzTDSBFHtlJJqHJJqdHQdTCdtCCdt
+WggGpNVVgWdwwHQtlGlC
+hjbWppbLbLZLjVPPjPLSRRMvDlmSzDzBSnBFZf
+nVttMPnPLjnJLjcnPVCjJJLcssfggBNlffgcNsWTcGcgNsBF
+HQbwhmDrRrgFsWlQGNls
+pZdbGzGrGpVttPLttv
+LLbMrMHLDdWhmgbqqt
+jGSQZQTpQGVVRSlQMQRljZmgmJBSvggvBWhJmJWvddmt
+VjlQFGMVrFFrDrPw
+DZVDwGZlJlVlwZVDzNdqfjMDnjqzNnWf
+pmtpLRQFhSFpmpRgRtHNFznNdqWBjzWfnBjMWf
+rHRrhStppHdJcGJrrssCsV
+pgQqHwgPcPCddCjdWtdp
+VfZGVFfNVhZhzjjjLz
+fNNBBnGVNfBfRSRjBRQHJQTwJcJTgHPwTngr
+MZdlzWzthMgrwmGmqZNqNs
+VvJQJPVDBJQThwwNsRqsvRsHHm
+BDQQPTnDDBQQBVfTBQPdFctzzdtztMMtnhcWcd
+LjWjDShflZRRcZzfHH
+srNwQPBsrVRhNmRGHzmM
+rBdgQTrhdPndQTrsQQsrPwnTpLLCWDpSCLtCnvtSWpJjDCvl
+gSlvDwCvcmcTQTFtRMjWHFVVHwtj
+rbsphZZzBshGZssMffTVRFfFpWpfTH
+GZNhZBhPBzTPNLDcDlCDCJNmlg
+smZjGfvjbWWffQtf
+dwRrdlVdDdgDbNtgcgQSNStQ
+FdFVwdblFlzVrlwrTlndZHHZGhmLhhssjHhMjnjq
+QFvQVFLLgVrFLBVgGhTtllPvmHRRGbTm
+hDCCNCNCJNzWDZnqJDzSNCTnbRttHGRnccbPRtmmlmHc
+qJshNMCNdVFVfsLB
+FcLZZPFjdZcZMPcRjcRTgbpJlwbbTlmdTlGlwD
+nrrNrHWBNSWvBqvvrhBqzStrgGnnmbwsbbJbwwJnmwmgJTlD
+BCrrNvqWvSQPcCGZZRQQ
+vPwcJblJzJbJcJFcwBSvJNdWRLtdsddGWWddWRWsMF
+mDZmmDZDHVhfmjZgjVDfhTZHtsNptRsMntnWdsMnGtRntG
+mhQrQDDhgqTTNfhmVQVBrPlBczSJbbCbCCPPvb
+ZjbjLlbZjGqsgJTfHggrVvlB
+tFDRFRnMFnnWtDdMdDRhzHfTJhJhffHvHTBHTgcfJV
+nztDtdWzCCMSptSdFRRswZjsLbjwZmwqwGqpQV
+vnvmmVnmVbrBJlzgWQWVNFzNHV
+MwSjZhSwPjMwfDRzgWlNpWvHlgNNNP
+CfSZjSfftwZDChDRSnccnrvBbbGrtBvctr
+LCBRQRBQwRrCVLVWSrCSwCptzvhthvGGhdHzwppTTddv
+mFnJJmnmFFFfPLNNmqqNJDpGnGtbHTtHvhnHbzvHvpGv
+lMMPLqDmNMVSjjgMCS
+zzPzbLjHLjfQPQHwwjddFNsNSJjDMsdNMFsC
+BqqtmgDhcqdSFCdsqddF
+GtcmrvhgcZlvZtBhtVgrvrvtnWzDnQbfnwlfWWRHWbbwzHRL
+JfWHWZcMMdDLMPjRnCJjRbFgnblF
+ShtBTSmBhTtqtfmqSTNvmjVjnFbFnnlrlqgCnrFnVg
+vfzTTthppmdzPLHLWdGZ
+tdvrvGgGTSScnHcjcg
+zLLVfzPPcDZnPjSPpD
+LfffNFLNlNbJwrctthWqNdNq
+NdjJtfVNZnnFFdtfGfFNcvpbMDbzdcTbbzpvmcDR
+PHMSHCHHWrRCvzDzDChT
+BqPWSHwllSQWrLHQHPqlBBNfttZMjFQfjGtZtNjJJjnN
+CpZtMCMQQpCVWjMDVjPVQsWWqJJhbTcddPlfhTRqchcJblhh
+NwDSGNmGRccqNJfT
+SBSSmgrrgGHnvSzwGVWDCzMCpLZtMsstLM
+sbjHQsBlBQrrGjQjBqCRSnSCpnfngLnFhJngFfSP
+zHVctHDcZtdJffnPpcSpFn
+ZdwNMztdvzVdrqblvWsqHvBR
+jPdjFPSbVDMMbqZzQWzQ
+hFRrJlpprGhtlJGQzmCRmZBWQCHRQR
+vThNplJpNhltNNlvcGDvwVFgnPwvSgPSSfjS
+DhDTPQpTDmQbDQrrrWtWPJNNrrsJ
+qqGjgwCgVRjMSRwMMGRGqjwvsNJJBZtrstvNBvHWHJvL
+VqqgfjzfgfFGVjRggCGznhlbTpQchcshpdFlnDbn
+DpTQTBbCZQVJQZJjrFllGdlvMPlMLqGBGvLl
+hmnWHWWNzzmHsmWRlGGpdLgLHGlqvgqg
+RzcWRhRnRnfmswfwtzzRWrDTrrFCQTCpQpcCrjjQCp
+HLvpHvGcBTDFznvfqT
+hCPQbPZPbjSbwwjCPChSClJJfzqTggTFDfsJngDg
+StqmmZbdqrQmhQrrhZWcRcGBpBHWVcLctMWp
+dNnRNbRdbRJMBMBVVThn
+rNrsLNscFsCDjpwTMgBGWMGjJjWBVJ
+wNcLpqHNsCprsfLFsHwRvPSSPRZRtRQSqtQPmP
+PPhGfbthhBDVsTDtDqRR
+mCmSNmqpcqjjrCScWRsZDpHsDQRZQDZDss
+CcWzNmccrjjvqBGzzdPGnv
+SDRmCSFfcSFFcfDmDBFSCfdVJhpzZjNJTNzRTvjzjhzNjTtZ
+ngGsltrMWrblNpNTJJplJN
+PGGnGsWngrGLQHHtHHHgWsHSBLqqfLcqBdVdcCDDBFdCDm
+VPjGwhwVPhrnqhzJmQvQTQvmzBzw
+ZBDBRbLLdtfRLlddLlCLCZMgmFJQFDcvzMQmgMzzJJFJ
+LHLWltHlRZCtBVhVVHPjGSpphp
+JqhlhdnnmfRVVSpzWLjzVLGpvB
+stQtFTTrsZQPFQNNDtQgLzzSLvjvLGLBGSZGGWJv
+DDDFFgDPbTwbTTJMCMcbCqqmmRRCnb
+JbDWPDPPJJDMDjHPZHGbHGVZTBhrzBpdzszdTTphdNdWdrpv
+RmRRqllqffwFtqwLCsqTNvpCsqCNqvdN
+fmfLmStlnnfnRtfcnQbbjPjPPggZGVsMQMbb
+WJggvGDJSwWgSfgvfSMGqqQHBcPjcHChcQBCssDHCTTQ
+mlRnbrnbnltblwdnnpbLRdCCjCTHTjPTTsQcTrHHhCcj
+bFLbdmzRpvSwfFFNWN
+BHnDnQHnHMWLwzWPzD
+dmlZCrdqLZzZVZJM
+tRRtdlLCjLmqCRsrSLrvvRQNFQnbgRTQQNHTBbGQQh
+ZrQPQWCrJnPdQSNTmBJNTHGHJN
+zhFRfswjwhhsFttfsfvQftRtLTzmBTHGTBmzMLHHLmGHNTTS
+hQhwqVjQwsdggrZZCWVl
+VjfnQgVQjblChfjVJlbzLtrSLlTGtztHTtsTGH
+DDqWQDQMWmDwWNwcqdWvpSrtLpLsptMprMStstMz
+vQcddRdRvWcwWRmmmmddZmmfVnnngJJbZnCBnBhhFbhCgJ
+gVgDnnmJdQVdJJgtgDjBsBhsBSPRSRRSSwccSbSqwPcCPcSC
+HrQHlHFpQfTHzzWzwScPPCRfLbPSfCSR
+TTQlZNTzlZNMWvrZMlpnhnVtnDDnVNtVJnjmhg
+MCmmssFnZJcNNszfpvvrpvJzvwpp
+BRRRWQWbSRGGRTTtZHWSqTrvDfgfdfrrwrDgfbvfzfrd
+jRBhWRWTSRttQBZMNchNCsmFMchP
+GBDncllqcSlNFZWBFWPjHVbw
+LQphJlJzLCwPjHbpHZvV
+hzCMJLMzTsrdrszQCCCTCQCDlqqnNmggqfGmgdmGgcmSNt
+hFVVbqJsqhcnBRTRGBTh
+lwdDpmzdNznzZBgGRRjR
+HdmvNvSCmDmwNDFrMJMqJFCRfsbq
+ctnbTcFTnbwSSfrrMLRhpJLMRdpwdJJR
+vdGCVBmGVHPLBRWhpRLJJZ
+VmQPHqvsPdlQsVHDftnlFTbffnbttfTF
+LBJZHrhLThHddcMLVtcMcL
+CPMNFDDMpGqFjjSPDPDqdvmdtQgVQQcQWcQgQQsj
+DzFDFMRSFPSGTJJTJBwwRhBw
+dpldqlqlRppFTHpbjbnLRLVnnGfjtG
+NNJTcmhzvJQNgMJBwcGtjtGbttfhtsGGnhnt
+rzcwmgvcvrBNvvmMgvcBzwHPCTWWprqPHqTFWdPCWDTF
+BNllDRTNqDNvNDDLBcDvBCLVJrVdJdtrnrCHggtrdd
+mppFMFjpMFZQZQGjFCdgrCrCdrvVGtJJCC
+PZsQmfPphvPjSsjmPjfZllBwcNRDNcDqNNWbTclS
+fjqZBSDSDwwsQwCDND
+rrdMdjVWtTTPslsslFLTLCsJ
+rvPWbvcmHjmdPbHvrvBHgqRRgqHGgfZGfHRS
+ggTQgsgwFrTrggbMTvSdmjfCmmQDcmqjDjmc
+nLZnRhNZnnNHZhZVStCcDqjcqmjSjH
+RWGNnhzBnJJRRWNRBNZNLZhFMTFPvrTrTlsggPwSlFMWTw
+RNmnPRnLGcQmzBQpHHjTltjtlfgspbsq
+CZvCJwZMMCCMdFVcwJJsgTTHfsTlbfbgbT
+SSVFhWCZdSCcWCcWdrvhzmnnnLNGDRDNzzLNGz
+jPwfPwNfFpFNQpDjdMcjcrdddDHD
+tzsRsGRLzhLhvqvhHMlqqV
+LRBnRBGSnBSGsGSGmGtBJCmnNWZpPpTNPMwQMPNJFZTTNwWT
+PCrStRPSPvZQcZPvqvfjSRWFFNFJFLZTTJTTVZFFGLFF
+DlpBzBntHDzhlpGJVHLwTMFLVLTL
+gptBBdgzpsBbpQvvPQPRqrdcCC

day03/src/main.rs

@@ -0,0 +1,130 @@
+use itertools::Itertools;
+use std::fs;
+
+fn read_file_to_string_list(file_path: &str) -> Vec<String> {
+    println!("Reading file {}", file_path);
+    let contents = fs::read_to_string(file_path).expect("Should have been able to read the file");
+    let mut splitted: Vec<String> = contents
+        .split("\n")
+        .into_iter()
+        .map(|s| s.to_string())
+        .collect();
+    splitted.pop();
+    return splitted;
+}
+
+#[derive(Debug, Clone, Copy)]
+struct Item {
+    name: char,
+    priority: u32,
+}
+impl Item {
+    pub fn new(value: &char) -> Self {
+        Self {
+            name: value.to_owned(),
+            priority: Self::get_priority(*value),
+        }
+    }
+    fn get_priority(value: char) -> u32 {
+        let char_value = value as u32;
+        match char_value {
+            65..=90 => char_value - 38,
+            97..=122 => char_value - 96,
+            _ => char_value,
+        }
+    }
+}
+#[derive(Debug)]
+struct Rucksack {
+    duplicates: Option<Item>,
+}
+
+impl Rucksack {
+    pub fn find_matches(front: Vec<Item>, back: Vec<Item>) -> Item {
+        let matching: Vec<&Item> = front
+            .iter()
+            .filter(|front_item| {
+                let matchfromback: Vec<&Item> = back
+                    .iter()
+                    .filter(|back_item| back_item.name == front_item.name)
+                    .collect();
+                return matchfromback.len() > 0;
+            })
+            .collect();
+        let item: &Item = match matching.first() {
+            Some(a) => a.to_owned(),
+            None => panic!("No match found in rucksack"),
+        };
+        item.to_owned()
+    }
+    pub fn new(value: String) -> Self {
+        let front_values: &Vec<char> = &value[..&value.len() / 2].chars().collect::<Vec<char>>();
+        let back_values: &Vec<char> = &value[&value.len() / 2..].chars().collect::<Vec<char>>();
+        let mut front_items: Vec<Item> = vec![];
+        let mut back_items: Vec<Item> = vec![];
+        for b in back_values {
+            back_items.push(Item::new(b))
+        }
+        for a in front_values {
+            front_items.push(Item::new(a))
+        }
+        Self {
+            duplicates: Some(Rucksack::find_matches(front_items, back_items)),
+        }
+    }
+}
+
+fn main() {
+    println!("Hello, world!");
+    let stringlist = read_file_to_string_list("exampleInput.txt");
+    let mut rucksack: Vec<Rucksack> = vec![];
+    for string in &stringlist {
+        rucksack.push(Rucksack::new(string.to_owned()));
+    }
+    let priority_list: Vec<Option<Item>> = rucksack.iter().map(|y| y.duplicates).collect();
+    let sum_of_all: u32 = priority_list.iter().map(|x| x.unwrap().priority).sum();
+    println!("Single bags: {}", sum_of_all);
+    let mut group_bags: Vec<String> = vec![];
+    for (a, b, c) in stringlist.iter().tuples() {
+        let group_bag = [String::from(a), String::from(b), String::from(c)].join("");
+        group_bags.push(group_bag)
+    }
+    let mut groupsack: Vec<Rucksack>=vec![];
+    for string in &group_bags{
+        groupsack.push(Rucksack::new(string.to_owned()));
+    }
+    let group_priority_list: Vec<Option<Item>> = rucksack.iter().map(|y| y.duplicates).collect();
+    let group_sum_of_all: u32 = group_priority_list.iter().map(|x| x.unwrap().priority).sum();
+    println!("Group bags: {}", group_sum_of_all);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn item_construction() {
+        let lower_a = Item::new(&'a');
+        assert_eq!(lower_a.name, 'a');
+        assert_eq!(lower_a.priority, 1);
+
+        let capital_a = Item::new(&'A');
+        assert_eq!(capital_a.name, 'A');
+        assert_eq!(capital_a.priority, 27);
+
+        let lower_z = Item::new(&'z');
+        assert_eq!(lower_z.name, 'z');
+        assert_eq!(lower_z.priority, 26);
+
+        let capital_z = Item::new(&'Z');
+        assert_eq!(capital_z.name, 'Z');
+        assert_eq!(capital_z.priority, 52);
+    }
+    #[test]
+    fn find_matches() {
+        let test_rucksack = Rucksack::new(String::from("aban"));
+        assert_eq!(
+            test_rucksack.duplicates.unwrap().name,
+            Some(Item::new(&'a')).unwrap().name
+        );
+    }
+}