dumb readme

Cargo.lock

@@ -5,3 +5,28 @@ version = 3
 [[package]]
 name = "aoc2022"
 version = "0.1.0"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "nom"
+version = "7.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8903e5a29a317527874d0402f867152a3d21c908bb0b933e416c65e301d4c36"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]

Cargo.toml

@@ -6,3 +6,4 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+nom = "7.1.1"

README.md

@@ -0,0 +1 @@
+# AoC2022

inputs/day3.txt

@@ -0,0 +1,300 @@
+BzRmmzZHzVBzgVQmZLPtqqffPqWqJmPLlL
+hpvvTDcrCjhpcrvcGGhfLHMlLtMCqflNlWPJlJ
+hGjhncHhGnhbTHczBBZVVSbRwgSgRV
+rWVQjPQQjGRWNSrWrPjcptwBpqqJBtJBBcZgMdtq
+zzmmpzfTCFpTlMlJJwBgMlqMBt
+TvLszpbhhTLmsnRQPDQGWDWRvQSR
+zGzvLlGlQHLGBQZlhBWhdjRdmdWRcjPj
+fTJNfTfNSRWPhjdjfj
+pbsbVVnpSnbVTprnbqqrzvLLgQlGLPLHll
+ZCCCsWvNvmsCsCmZLZmgMLRpQMhwQRpQRfphfprpTfpM
+tlncPjzlndctbzcPPBcjwDphwrfGGDffbDRpDTGG
+cdqnddwzqjNVWVLZZLZq
+DTLbDbRrlQbwhhNrmmfwdt
+zzMJMzjCjJJjvLjMPJpcgPpzfhHdfqWcqddwtwfqdttcNtdN
+pJCzVpCvDZBLsVRQ
+STzBBbJzRRBZBRTqCCsfZLtNNLClCsfh
+jsQnnQjjHcvQFrcPwCmtLCNlvDfftfff
+sGFscMQQMMpqzqbMbd
+QlNDWGsjQjgQllWQsbtzqTJczTJcbFmmFJJP
+MhLrhgLVndRmzJFzVqqJqP
+pSLnMdwhwdRZRSwhLZwLhdGWQjlsgWjNQWWSvgBsWDlj
+THjSRFSddTjdBTcPLcVVvVBw
+GzWnWfndWfznDfsnsBsPVwVwPPLL
+zNflzJWqqzQDdSStHNZNpFFtbj
+FSzDmsFSFlDlBzqVjqHHjHHpVgHLbp
+rTrTtTQQntRQnQJQgggHZttVgHLBLhZL
+WTJJRRQCRRJTRdBCRdvRNDFSWFMPmDlPPSsNPSzS
+WQldlMtMVQgVMQHnDGbHGGnRnQmD
+rqcZPrCFjmHlbGjZ
+zSScchqwchBzTzFzhhSlcCwNtdVWWJgsVdMtWNgNVWTJTd
+lMZqjMWllrTTspjprWWSSwgWNSVNDmWGVwFwgN
+cdCCdLHcnndHJnmCRntLBnRzDvFNtNDVzgSgwDgFNVzFVv
+BRLcCCJCmJdcRhfjPPZphrlrPqlZ
+GdGqcrrZGDrvDJJqJHcBvmFFgmFMMgMgBtMLTssLmF
+NbPVPDlljPmTmsTj
+VfQDhflCCRWdcrQwJvvnJv
+RLcWgLCqqPQLcqZwzHgwmmrmmtgwTw
+DhbhNrMpnJSDJwVTHmmTVnTTVj
+lrsvblMDlcWcfQPQ
+PVldlphHwGwJJGdjZZWsRbbsGsNWrWQbNbQR
+SqcDvTmDLtfmSmtqppfqzTgTQBrRQsbCFWbNNFQFBBrRbLNb
+MgtmTgtfpqVlnVddZMwV
+BdmfmPBPSbSNdGSdvWrwcZrccZPPcZnH
+jzzLsjsMRlQQVHwswvvZrCHrrT
+VqhzVFzplFlpLwpMphLRQQVRmSqgbdGtNJBmNSmgGbtggSgt
+DHVpNZjdZjFZWVFHpvFvzmlRzPnlfznFRz
+lrTBTsBwwMbrrwLPPfwGmGzvRf
+scrtMhMCtJBBBclbHdHttWZWDSqDSjHj
+wzqsPmqsbsfqBwPMNRMMZcZmFFNtZM
+CgCnhlvvLJgcRFNNBdCpWM
+QnQrVgHSvVHjbjTGBbbTHb
+HdrVrdqFDdZVmHgRmDRFHMnTdTssMGnLnPJLbPTbCs
+SczlScjwcNzplNzQSSfjwQSrTGGsbTsnTCnGTMCMLMGGbN
+wQlfjrhfhQFHqZhRZRtD
+RsfJDGJvzPNcjpddSWJWMd
+LLCbBCwCrCmVVnrmhQFmbVhdcdlWpjZzSpMdWSpcWczSBj
+rrLCbTwnHTvzvNGT
+wPhPhbCqqSCrtJDlqvlrJr
+RVVZddLFRZZcQLvJJtzptlgPJp
+TVQRZGVncFdTGWZdCNShHhfPNwwsWPwb
+dzLVzPSgrgDDDCMSMLLPwFmdTTcsvmwNwjNsHcFF
+nWBGntQfGNGBflWBBqlpRQGbWFvjwsbsFswbvTHjjbmHTc
+tBNJBnGBflQnDPJrPhDgrPVg
+VtWztWtqpqzWpWzqjNRjNpWTmrrmrSbnmJwSJwnMPrCSJVwM
+sDHsBDhBdsBZGcHvLHDLhhCSnRSwCJMZrPbmnMbJSCSR
+ccLRhgsLBdRsdHNTFFNNgqTglqzF
+hztlmDhPhgPlPNNgmZMCbmwwQjcwjjwMjVCd
+RSJRrRqnqQJFqvnTGrHCcHHCCHHbHHMcMvdM
+qGJsnQTRsStsftPlhPNl
+BFFBLPRCwsLwhlPlRmhcGGrbmmGjfNTTnp
+VJMVpzgqggJnrjmjNcMjmT
+VqdSZtQgZvtdzqHqHtVZdVQpCDWWFdwlRPDpWPPBCswlWD
+fCWCsjPzcbzwRSzVTzhhDLqvdg
+TmJtrNJrBLSLJqgS
+ptNTQFHrZlnpFPwsWMbRjCpcjR
+nJmQNCmbmlllmbClbfMLjMFqbGBsdLFq
+ZcgTWcTnMqqMTBqF
+tPgctSnPctZZgDWzZgQHwNmHlhlmzlQhlJlw
+ZpTCwpffdslvgShCBhqhRz
+FDMPnNFNmBPzvRPRBg
+nNgMrnnDGjDmJMmnFdZTTsdsrZrslcwcQr
+pTmczpCldcdDDnPttpvWSqbpJf
+jgjRZMGHhGLgQrjvPWzPJgJvzStbbq
+LGNLLNBBzcDFCBwwFC
+nJTTqnrNvTzNMzzNfqrTPrJnwpwPpZpsHccZVsBRpcVHwpcp
+bgDhgbghLWmFmStctVpZtBCVCCpfZp
+LLSgLGSjggFGbSSbmMnrvqvzjfzTNrJrqM
+RRpDmmPMTjwfGmJQgQ
+WsNscdnvvdVZFVnnrZbjjflwljlbzfGFjQjq
+NnLZsNnrrVVVcvdBLTPCPCRMwhPMBMPhCt
+lbVvzngGJnVbJHpHtHNPpdSQvc
+TsMBswFZsWMWBZMNwPtNNtRNHcNpSQ
+CcZCTrZDsjZTsTsshWhrWrTnfgbLDfJzVVLVVlgfnzfVGV
+JzTTRtJRZWmWjrMHCT
+DDFGlLGcGlSSSLsFGBspPBmNMBHMghmWNmWjWCmWtH
+nSSpnbsGlLDnpPsSSspFtVvffRQdVzqvvbqdfVQwRz
+sMhzszlHHDsWbthHDqsbJjpLNtmjVJmVLLVLVLBp
+nrTPrGwfPLdprzJzdL
+wgPQcTGGzgccwCgnRwgRChFhlWSDqWWQMWhssSsMQl
+NSNmwtpSpCpvMphCsr
+PHcRGPLJMrsvzsqG
+QHjbnRMcfbPbQZmlZgZlgBBQ
+cPRPbhQjbQRdtPQdLqLHqzFZjCFCqLjC
+mmfsnnwrfvwrfSNZFzHHLDCFNlLlqDlN
+wsmrwswwGTffMrBnmQttJtcMZQQtPJPbZc
+MvBPDDRRdnnvHPCHZLHZsFLL
+rmJcbVqbcjWwWjQHLzTZFTHSzFrpsz
+cmwllVqqGJbVVVmmqbQcmgRnRvGhGfgDRDZBBBvRdd
+nMvMhMnvhnbTZWSSZgHmGJDFmmNDzBmbNmdGBN
+rCsPLRCssRjrLLsrLlwRVrcNJQfDQfdBmmfNBGJNzmDPfB
+CRjCpLltgtJgJJWq
+jshCzJpjzTPpmCWvSlpfwHfSWglf
+LQMMNMnHtDtLVRvwwgRWlldgWD
+qHVrQNHVMFQtrrBBQMBcrrZsZbzCZhbbJZJsmmsmFPTC
+JZQZnsQNMqTngZqJBVfBfPPVBNrwvfPw
+SSmDstFjpDpCszDjcLLhrPVlGlrGGVBwrvwVPt
+FSssFcLjFjbmFFCzjLcFLRDnMJnTHRnZZTdWqZZWnMnRnZ
+GbHRHpldwGMpWhHpCMBlCbRdVSLhnqJLSrDPLPPLPDqVDrhh
+gvjWWQvgZFtQFFNqLnVnDnSJzzztDD
+ZccccfTsffHdWWdRWwsw
+ClCtbHMlnnPPlszV
+gSDWSLgWQWQJJNWqgtQjPsnfcdVcLVdVdzfzVzff
+WQgqtFQgDgQSFqJhqhSJvNDRrZMZHwHMCbZhTpZbGHMTMG
+pZJZlCQtHFhPfdNfCh
+zcmLSVczwcMcLDNFHdLPhPWH
+szvVVnBmnTGQtHTQ
+RVVCNDlNGzlGZqHGHWqWhGqQwH
+ZFLFTmpLvvmSqsbb
+TrfpBfJpJMlnnNfNZD
+qHHlDClHhltMqQsHDhHslGznwdTnzzwDGSdfnwGnwG
+mZRNcNcLLPNPBFFbbPmLmbZFSCVfJJTVndVfSwnRzznfTwCS
+CcCWFbbBLCWtgWgHjghqvv
+TjbzlnlFmfqCFFVVCRWr
+PhMcLpPDtMLpwPDvLPJbMhSgVCGqggVqQgCqCgCgSWvv
+btbZbNZhJDJJhDtwtsTTTmBzzBBmlNlmHj
+FqhjWtqlqmmsnFPTCvMCQMTTCjQd
+pfffRfLpgrgGgzrNVzzpGVzRCdMCPJbwwcVMbQPCJVMVdbww
+DGGDZRGrHggzSsFQnnWShmtH
+vtHVVMMrvVMVrSHvLgvlHcZFCnRCZcccZtRRZfJFCJ
+rdDjGsdTQDcNZfdncCRR
+rBDsTwBbjbmbbQswswPhqVmmSvpVhlvvqMhHhh
+vGBLrqMNvqSLBvvrNbllLHfwStWWtFttccjtRtjtcj
+MhCDJmhMDzmcRRcjzWfztH
+ZQDmDhVVCQbBVdVNMvvv
+ptCtCzhWPWptnhVzzpGZbZTjTjVjFGjVFgVl
+fQswRRffmRqZlgrqqFjjSgGg
+HwsQDNNsDsmRLLHmffsfvHptBnhtzCvhWpZWBdhnMdCh
+RlHzzTqczBPfbnvcpB
+wVtNwpSZstppwwMsZhsdnLvnbtBBmbnLFFdnmF
+WNQJMVWsZWwGJWhhSNrQzlgHrDCgQRHpCHrl
+RrZWpJZRrZpdTGstlchLGGlLMd
+NqjDPCQPnQCSvtMzSLhhjM
+nQVQDDDDfwBwNCVCNVFNpWpgJgrRTmLTmTmgRTWF
+SHMcrMHpcjGcjSrMMbvSvvSvwFTLJwJNtFGFWJNtDLFTLfWN
+zqRnPfzQCRzqsmRPzznhszzLtLwQwwFTgWWLDLgWFTwTNQ
+qVPZmRZhsCZPhZlRCqRRRCbfpccMBjvMVjdHjjMjSvdf
+VVQdHwBZLVltlddtBczhrzvGcWWFRwgsFG
+TDTTTqqTSSqjqnmTmPqPPmTmGhRszvsrzsjRsccgzrRzgWGF
+DpJPqpWqHbZpllpt
+cCSCFsnnZFnscDtNdJFJtJtdmb
+VgBqBsqRrHtNdzmNrt
+BGLLVVjRBsqPBfsGwPsMfSSZCSfTZTZQpSphfS
+plCHCHlgglHHGpNbtngNrDvBDpfQDBQfZDfWZVrr
+mTmMLhRfwhsLPQvQZDMZQBQWMB
+cwsssmqRTFFfFgtbCtGl
+LQPPrCPnMZwqtRMn
+cWTSlJWlcplJdDTdGdpDlGcGgqmtwwZtqRrNRRmRdNZqmgNq
+GSJcJSjsjTpsvWGWBHLLvVVBBBrFrzVz
+NVPCSPMNDSNFVSWCsJJJmpGmZZGLLcpZLHGGtsHt
+fwzlBBqghqvzqqlDrHbpHjZHmGZbLZrHLb
+dnBgnDqQvwRnSnnFMFMP
+BCbPsFFwCRHmDSBmWnvDDj
+phhZVzdpVfQZphhZpRhSVnjmrcvvnrWtDrvWDS
+TfQJMfLphMhJdfdzpQJRTPbwHHNlgbGwsTGgCP
+ttWLlnnvnNnBBtlTqWlpvpndQdZsQQFssFDdsRFdVdRNFQ
+jSgrScrbGZSGrrCGsFVMssFsPPFcDDMV
+bzSmJbfCZCbzLwllflwqtvvw
+zmFTJwFLPmzLztmjDzTJwfNrdFNrFppBSNRGNGdbrpBR
+gqlhWQgsZMsvqMlMMvsvqsNlLbcdppbrRpdbbcSrrbbr
+vssCgVgCsggZQZCgsnsqWgWvfJPDLwffwTPPmzTnjTPmPmwJ
+SpcRTPQLBLWpNNzjmmwwwRrR
+tGlfvGhfnbDlbqlChnfFMrwsmwNssTMHMHjFwv
+ZlhtCtffCdWcZWZVVT
+jTTCcWHWJNgCGTzTmnzrmnGn
+BwRRbFvtvvQmJJFMpMJr
+ZBBwLvqbBZsRsbVsZSqbcZdJjHHjhfPCJfJfHhgc
+VrnDSvvrLrfTdTLGfdRp
+zcJzmcFcHGfdGmWTVd
+tHsMhwPVctccHFHFcbSDbbPjnNbBnbvBQB
+QttWQwLTnLnWTtnffnLQSBFVjNvBjBFNgMdCsVWsjv
+pDqcmmRPHqgVBddjvN
+DcclzbcbPbJLnNTfnw
+plRcpsZDGlGZvWvMCNcLtttq
+SrfrwSjSVrSjwbmSrHzmHJCQQPQzqttNNQJMzJtqMW
+wSHVnfHfWwwHWFVfSnfgmmRsslFZZDBBGZsZsDTdGRTp
+qSFQSgQNgQBrBHHcrW
+VTmjVJLTwlTmwTVmsMJMVlJmPvcbvvbCBbGBPjGvBbBGWcbb
+DnJTZwmnZRhnpqNdWt
+dTVHjZLLZDVCfVHtLDDjQbscjWbSJMJPjsbWWb
+FnqrnmzzFllmsWwtsFtQMMFc
+lmqzzzngGmlNNBqGllzlBNRvptHHpTCHpDLpgDZdgvHvDD
+sdRZQbCfZTSTdlfTZCffccWPHPPcPPwLwctRnLWn
+BBJDzFVgCDrCJrqDJJhqJVVMLPHwcctFwcWHHGLcwGwGHnWc
+ghpJgqqjCZbQdZpd
+tbcpzbHSszcHBgqHGZgJJJhhww
+jfvdvRTffQQrrFCRFTnGwJRqNRZVpJGZLZggLh
+nQTjTnMndlTdQFMvnrClCnpzmzDtbbmBbcPSzzlmmtzP
+BqBqTCSTcqHsJHHM
+WWPGVPLtzVgWtjWPGzVjzVGcbDhPsRbDcsbJwNRswRDRss
+VQfWjfLFGWLjdFfVzTZZpJTpnmlTrSQlBl
+jLNsZjqSHCsGdsmpsm
+MvnVFzWMwMVWzfnVDwfBMfnnrCtdtPmPlRrdrJCJrtPDrrPD
+zznfFWwMfMfFMwVTMQFnQjhjgjSZhCNbLSTcHHgbbC
+GGtssttVmvnnGNMQrrVzgwVrCWMz
+FdhfhhcCDhHLfzclZMcrwcQMZM
+HHqqCBhHSSpdmjGqmGjtjtjj
+bbQLtGMQQtQRQtrDtGprrrbCqwplZhhqSqmdwvdzqqqhSmpS
+FsJjJBfnsJcFcFfjVPjWBzldqhqnlZZZzzhmnSvSnm
+JPcFfFWjFHJVVsVjPVscsDlLNRHGDbLRMRCDNrCGbG
+JdMdlMRJnTwdvcjv
+CDLHbNSzzLFgHvnTjrswBNBTNT
+QgbvzSFQmZQPQQRW
+NTBrNzrpjjjCwGbB
+FRbQlcvFvcRQQlRsMlRRRZjwCqMwjmjwJZdLJmjCZC
+cVPPQcvlWDNhrbPz
+VdbVtbbZJdtJVVdDVZmTLqqTSQvNLjjDShhvSG
+zplpnBnFpnrrlghGNpLNqHvqvjNj
+cWncllnlPFWzcMwtWWtsVLVRmJWCds
+ShLSTnZnTSttTSbLQdfSZTMwcDHwwcHnJvDHnlnlclMM
+NmPMsssRrVwjDclHJwwR
+gNNMWGzNmqGdtfZTbGGb
+sWNNlRHnmJtmntJt
+brbbBTbbFbCbqqGgBTrCfmQVVZfSSQQSVtJZSrVZ
+bbFqvbDvvGGLGbCCtBGDLbLlcPNHhhccPNcdPPchlsdR
+DCFvDvnCnNfMBmMMslDZML
+SQQQJHwpSgJSJHQWSWHqJWWbmcBBBLLTsmhhTcZbMhmlshcb
+RJRgpJHssgwSQHRqsQPGGjjtNCrrFvvnFjjPrP
+mThmsgjzTPjMpcvtWP
+GNNBVqVGNZbbNbNqqZQVNVNbWcpdtMCcpCtMWCdCPpQccmpp
+VSmNrmmbBfZVlsrssrLTRhRhTn
+TdmCvLDCpTRNTdFbbWnnSWCfhjbbzn
+GrrMsPVGcQHBGMbhjjSgWfHHDbjb
+BPBVqqrQPsQqwrrmmmJdRLDDqFRplT
+fpDDJljDlCfDTjprjrfbddWthCSCtdPPQFhSSSWW
+HsLZgMGbgBBsNzMvGbdVtVQzFRQSthhFPdtP
+sMBmGBmbNvLHGMnrDppTcJmcjpqljf
+ptSpSJQqpbNGGDDhcMWrlNHcZZWWls
+zRLRRRjvvgjHMMsMpWpc
+vmCPLCgwvwdnCzmvLbpTbVQqJJPbJPpTVq
+TJCfhhJVFffrJJQQllNWcvWhwvWD
+GPSGjjpLslBbpLpLqqqPDvdwvwvNzQWGzDDNdzGN
+msbRjbpPqsRpHnlZrmJlnVHT
+GGfFsCCTvGDsfTTrhsCMMzptZJMdpdgtrpdMcV
+LBlwBHPSqjwwlVggHpnMZcVHMt
+ZlZZlBbRPGGTGfmRsD
+CtCjbVvzQQZTWVdd
+MlSqWlmsmGBSHJHTDFHZ
+pcqsmsplwsqclwRtRWgtRnPPvb
+zCrzCrsdjrhGDCFqGDjRRPtpWfQQcpfQZcCZPp
+VSVwVMgLHHLTwMDTMMVnbWPRZQRcRQPptWnpbZcb
+MNBBBlSMvLVwTlVTFdNdhNhFsqsGDrzm
+rBLWTwTThWwVVDTwHBsZZWppvpGtpptppmRvFFFMFMfL
+qPPNCCbqcbcNqbqQjjJQqzjRpptmlpMGmMlJtftmtFHpMt
+QnCgzzQbbQqPcPQnncbdQdnVTwDssZgrShBTVgZZsBSDHT
+PFGJFqnfqmPgFJQPWdbLdpDRhbphWjDm
+rclNHvcrzCNwrWRprjdMMMph
+wsZHwZNvRRQsQqBV
+LqlGCPlPLTCPqqQlpqLlWfBfWgcHNRJRfWNsncGH
+VVtdwVtDDdVmhrdwSBmjbdzNHgfgJnNnsSnHsNffHgRsgR
+wVzhbjmDbDrwjdbztFDDthMCvqPppZQBQLZQTqTvFTvZ
+BnQnQFwRmRwmwdBSFDFnmSDVLCJTCTppVVmGLVTCLcgVpC
+ZlWvhvZjNrbNvqjNhlfPfqjCGHrsspggTpVLpsJCpcJVgg
+vPzNvqjWhqFzGSnRGMDG
+wZnMZzzZZchDRtVsqtCtwV
+WmWpWWmPPWrmrmBmWrTlTFPNVqVCRSDCQHcqVTtTqsSDSTSD
+PrppdFlWWlfrWmpWFffrdcGjJJGggnnhZGdLLgGGndvz
+FShHNmNhRhNJmBnQBQJrmP
+VTgzDTjwfffwzDvwlcczzVSJbQlBQSWBWCnPJPbJWWbC
+tzSVtzvSvGSRZqqFMNtpRR
+hPZhGDZpnCGtDhznjmLmdJffdNzJ
+glwsSrQwBvLdgLzdcj
+QsRbHllzzlHwHlBszWlTBFbpDPMhbPDVGpGFpPtFPp
+SRjStRDctgDSBzLvPvNrDhmPLr
+QqTHGTPJmmHmhNmH
+TGQZsTqFnQZCJTPsnJnZQMjVRBVtcVRSVRBlwccSCtBS
+bbsNsvsvnNPTRRllbblLqhtQCqQSLCGGHSqHNC
+wFpzFgqVzqVJWFDwqJDmSBBmHBHhShLQhCGSBCGH
+MJVpFMqgwMqRRbZsMbZMrP
+PPdDhvNDQdmgQPZmQVHHtHGGWVGbffWGvs
+MMLCTRRLlLclTLRMRLCwMLHWVctbVVHWWWFfVjVGsFWW
+MRSMMlpTJRqClBCRqBDnzqgQPnqgznZPZqbP
+MrMNPNNpjvdprWtrpMsthqBfqlnfqcGhVBqFRcnqFG
+QbDgSSQbgSDDmDVmlqSCRllRcFqnqfBl
+QVJbVmwwDQbzVTgbppNJNMWNjNNPrdpM
+WwJJNbtHfpLpVgZZPVFhZh
+vmmqlDvRvRfqBSrlzmmMjRBhcVhQVZhVghCQQQQTcTrPTP
+jSqMmqRzMDDjvqlBqsBMBmmwGNJwJnwLNfbGwddswnJtJH
+RLgRmRggbvbzzPmmRNmzsQWFtSGNtwSNQnntFwnnCw
+pDBrBHpHhlldphHBHhJVFSLnWWFJttCtQSttSS
+hfHrpphHBppfTvmzgMmbLbgf

rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "nightly"

src/bin/day03_1.rs

@@ -0,0 +1,7 @@
+use aoc2022::day03::process_part_1;
+use std::fs;
+
+fn main() {
+    let file = fs::read_to_string("./inputs/day3.txt").unwrap();
+    println!("{}", process_part_1(&file));
+}

src/bin/day03_2.rs

@@ -0,0 +1,7 @@
+use aoc2022::day03::process_part_2;
+use std::fs;
+
+fn main() {
+    let file = fs::read_to_string("./inputs/day3.txt").unwrap();
+    println!("{}", process_part_2(&file));
+}

src/bin/day04_1.rs

@@ -0,0 +1,7 @@
+use aoc2022::day04::process_part_1;
+use std::fs;
+
+fn main() {
+    let file = fs::read_to_string("./inputs/day4.txt").unwrap();
+    println!("{}", process_part_1(&file));
+}

src/bin/day04_2.rs

@@ -0,0 +1,7 @@
+use aoc2022::day04::process_part_2;
+use std::fs;
+
+fn main() {
+    let file = fs::read_to_string("./inputs/day4.txt").unwrap();
+    println!("{}", process_part_2(&file));
+}

src/day00.rs

@@ -0,0 +1,24 @@
+pub fn process_part_1(input: &str) -> u32 {
+    return 0;
+}
+
+pub fn process_part_2(input: &str) -> u32 {
+    return 0;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const INPUT: &str = "";
+
+    #[test]
+    fn day1() {
+        assert_eq!(process_part_1(INPUT), 0);
+    }
+
+    #[test]
+    fn day2() {
+        assert_eq!(process_part_2(INPUT), 0);
+    }
+}

src/day03.rs

@@ -0,0 +1,61 @@
+pub fn process_part_1(input: &str) -> u32 {
+    input
+        .lines()
+        .map(|line| {
+            let compartments = line.split_at(line.len() / 2);
+            let overlap = compartments
+                .0
+                .chars()
+                .find(|ch| compartments.1.contains(*ch))
+                .expect("There should be one overlapping item");
+
+            match overlap {
+                'a'..='z' => 1 + overlap as u32 - 'a' as u32,
+                'A'..='Z' => 27 + overlap as u32 - 'A' as u32,
+                _ => panic!("Invalid overlapping item"),
+            }
+        })
+        .sum()
+}
+
+pub fn process_part_2(input: &str) -> u32 {
+    let result = input
+        .lines()
+        .array_chunks::<3>()
+        .map(|[a, b, c]| {
+            let overlap = a
+                .chars()
+                .find(|chr| b.contains(*chr) && c.contains(*chr))
+                .unwrap();
+
+            match overlap {
+                'a'..='z' => 1 + overlap as u32 - 'a' as u32,
+                'A'..='Z' => 27 + overlap as u32 - 'A' as u32,
+                _ => panic!("Invalid overlapping item"),
+            }
+        })
+        .sum();
+    return result;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const INPUT: &str = "vJrwpWtwJgWrhcsFMMfFFhFp
+jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL
+PmmdzqPrVvPwwTWBwg
+wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn
+ttgJtRGJQctTZtZT
+CrZsJsPPZsGzwwsLwLmpwMDw";
+
+    #[test]
+    fn day1() {
+        assert_eq!(process_part_1(INPUT), 157);
+    }
+
+    #[test]
+    fn day2() {
+        assert_eq!(process_part_2(INPUT), 70);
+    }
+}

src/day04.rs

@@ -0,0 +1,74 @@
+use nom::IResult;
+use std::ops::RangeInclusive;
+
+pub fn process_part_1(input: &str) -> usize {
+    let (_, assignments) = section_assignments(input).unwrap();
+    assignments
+        .iter()
+        .filter(|(a, b)| range_contains(a, b) || range_contains(b, a))
+        .count()
+}
+
+pub fn process_part_2(input: &str) -> usize {
+    let (_, assignments) = section_assignments(input).unwrap();
+    assignments
+        .iter()
+        .filter(|(a, b)| a.clone().into_iter().any(|n| b.contains(&n)))
+        .count()
+}
+
+fn range_contains(haystack: &RangeInclusive<u32>, needle: &RangeInclusive<u32>) -> bool {
+    haystack.contains(needle.start()) && haystack.contains(needle.end())
+}
+
+fn section_assignments(
+    input: &str,
+) -> IResult<&str, Vec<(RangeInclusive<u32>, RangeInclusive<u32>)>> {
+    use nom::character::complete::newline;
+    use nom::multi::separated_list1;
+
+    let (input, ranges) = separated_list1(newline, line)(input)?;
+    Ok((input, ranges))
+}
+
+fn line(input: &str) -> IResult<&str, (RangeInclusive<u32>, RangeInclusive<u32>)> {
+    use nom::bytes::complete::tag;
+
+    let (input, start) = sections(input)?;
+    let (input, _) = tag(",")(input)?;
+    let (input, end) = sections(input)?;
+    Ok((input, (start, end)))
+}
+
+fn sections(input: &str) -> IResult<&str, RangeInclusive<u32>> {
+    use nom::bytes::complete::tag;
+    use nom::character::complete;
+
+    let (input, start) = complete::u32(input)?;
+    let (input, _) = tag("-")(input)?;
+    let (input, end) = complete::u32(input)?;
+
+    Ok((input, start..=end))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const INPUT: &str = "2-4,6-8
+2-3,4-5
+5-7,7-9
+2-8,3-7
+6-6,4-6
+2-6,4-8";
+
+    #[test]
+    fn day1() {
+        assert_eq!(process_part_1(INPUT), 2);
+    }
+
+    #[test]
+    fn day2() {
+        assert_eq!(process_part_2(INPUT), 4);
+    }
+}

src/lib.rs

@@ -1,2 +1,7 @@
+#![feature(iter_array_chunks)]
+extern crate core;
+
 pub mod day01;
 pub mod day02;
+pub mod day03;
+pub mod day04;