days 3 and 4 :3

Cargo.lock

@@ -10,6 +10,14 @@ version = "0.1.0"
 name = "day02"
 version = "0.1.0"
 
+[[package]]
+name = "day03"
+version = "0.1.0"
+
+[[package]]
+name = "day04"
+version = "0.1.0"
+
 [[package]]
 name = "tiesto"
 version = "0.1.0"

Cargo.toml

@@ -4,8 +4,8 @@ members = [
 	"tiesto",
 	"day01",
 	"day02",
-#	"day03",
+	"day03",
-#	"day04",
+	"day04",
 #	"day05",
 #	"day06",
 #	"day07",

day03/Cargo.toml

@@ -0,0 +1,8 @@
+[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]

day03/input.txt

@@ -0,0 +1,300 @@
+ZNNvFWHqLNPZHHqPTHHnTGBhrrpjvmwfMmpfpjBjwpmw
+sbdzQgzgssgbglRtmjlwhjBlfrSrMt
+zgsCRzJbsdRVQCDbcgLGWWLnZNGVLLZMNZnq
+tvHhRtZGMvMHvfsrBBCTRbwbccRc
+qznnlpzzDppWlDpQpCrcrwnBNwTZnBTZrn
+PdVZJJqVZdllDPFtMjMgLjGMHvSgMF
+csbhhVDDvzlVDcbccGGvfRjDHCjNLRHRCLfmnZfR
+dFrStSTTmrrrHVfV
+MMgQMMTMVTdgWtwTPwSgWSgGbbppJzlplvhBlPbzhlhbzG
+FDJSTtSGhpPFDmFTZDpTFPmCBBrHqsCBhgBlqqrqrlRrHH
+dQwMtfdzVwWfwctwnfnQCHllzRrsNzrrgNlCgqsr
+fLfQnVjfwQfMdfvfnVvWDvtJPFGDpvZGbZpmbSPP
+TzzCrJcDrTDdLDCJDvGNPCFqlZWlvNvWpq
+RRHfjsQBFsjgjBQsWqGpNvZQqQlPPQPN
+VnHBnRVssnnjsSfBwbMSrrbTwJTcwSDF
+HJCgHCCFFFVGJWTlbqDdlqTDDpgl
+cZccSmLrfZcrmmzSQftdpDtTHdbQTDMQ
+NZZccrrBwZRPNNzmcLSSjJhGhVWCnsFnHBjGChsJ
+qwwwJHTHqdFDtZBFPfFBZFzM
+gVRcLnnWVgggnnnQgVWWNZtZrBfLBzZzBrMPPrZvPv
+GQgQSVRtsVnNRGSCdpmwspmbmDpHmhwd
+bhNgNfgwpbLMhCZMGQBmDm
+FrcHrSllcqcFFMGLBDQlMDTGlT
+FVSddRSJRjLwbjJPJw
+wzhhrTwwTrSsdHQjjSHnBjQj
+gRDCmVgRgMvtMfVMRBBBhWCHQQHGJHZJQZ
+NtgVgttVbMNmvsNlpcrLhLTNPw
+MCgjsfnscgjjgnGgJHHqHDgdHbGr
+QSSmRFPpRtPFQLQRmPzvBzzzDWqrqWWHJGGNrJJbdtVWHJDV
+BdSFdLQzRFlSLmQplffwncfscChhcsMj
+GfVmfnmJVnNVFhnhGmbmhpHvqjrzHZBjfvrtBHHZrwBt
+ddWQldlMdWMlQsLWTLQgMNwBrvjrZjNrwzZjswHqrv
+QQdTRcgTRPDlMQlQPQdhcNNnbJmbGpVnGchFmm
+CjjZCCZfvWZRHHhRtwhvPN
+mrnqlqMqBlSSLnBTLBwmHPPWhPPHtFRPWzwt
+rBVTrrMMSMLQBrndGcddWQbbdZfCZJ
+LFtdjHjLjLqHqstLTjFLFqNMnMhhZdDDNMVbWdDDbhnZ
+CrBpBGnzrzmczcllrphCZZWJMDWRbbZNMDMR
+GwgvzpzvrcmBrnfHjTgqTsgHjF
+rMPPZcplCZlZPwtSwhtBwCQQzB
+FvDGffLqqmQFwmmhzt
+TjJjJfHHVDVnHVgZZlQppcVscP
+hVcqHwhgwwwjHjjGWbvrbBGrsWVWGn
+CttPRpMmPDTWbWltlLBnGl
+pZmDFMmPMfnZwqqwfcqJdHgz
+bSJWhWJCbGGWJPStWTgRQwzDjgQQjsDW
+nFBBVQVrVBrNFMFZVpBBZFZrDgdTldgsRsslsljsRzTRjzns
+rMcZcHcBQPvbbHGP
+mSfmwqfmzrfHwFfmrwvPHqPmMFRlMDDZBCVVRCVZVlZpMRRR
+TWjdTWhTsssLTGsJNWhTQddjRMDMtNNBSCDBllMMBVtDMVRZ
+QhWTQcdhjThsdGbTLGjWHmffnmHwnwHrwqmmfcwS
+LmrsMQnnpfmMLllvTvqvFFzvFHNN
+WGRFVWdwZWZvCbJzcvJNzw
+VjGhDtWGSFRGjVVSFdjjDPBfspPnnMBLPLrrpMMm
+qqqCCJjtqtqCtqLZspHWBdSrWWSzzbzHFWBldb
+GhwwcwPFVDcNFRRGwwzmlBrBWvllrvSzlrcd
+DGGhQNNDhTpZZqqLQFQQ
+QfZmgQQZCCMLfNrgprdNvvdrTg
+hhttsBmBDcFRBlJshJcRrnjnTvNqpddNNqvndp
+JtsGJGtGGJJJHDbctllhZHmMwMQSPVPzHSLMPZmV
+DScSjZcNBZqjDDcLLfFtPfCfjfPvfv
+pTmRlWhdMwTLGwCf
+mRdWCVVglWrCmVHVrVCmdrbSzNcBDBqBZDNHqssscNzqNc
+sPMHGFMsrPNCPnNS
+ffJzllbzpZBllttBtfglgBTbSCVCmmrNFmmbFNvCFLLb
+cpZqpfgZZJtJqJJJfWHWhHdHWHjcdRdFHD
+ZZPfppvzMrlNBFcvFB
+shJgstJwWLVJwcrFFVFrBVNNqFFB
+HwWJdLHWWLcQgssHwwSQSQtQzCnZZMpZCmdzZCzpPzpCPRCj
+QCpLRbsCCQQLbQzCBQDQBBfTTffWtTctJVRNVtnfwtWV
+GvlqqlGlmMrdsvrhmlcTvwJtwNwTvfJfcWTW
+lMhgqGhddjqFFCzBBpbsSQpD
+JJwGJwVQQwVSsSMhQMQgHfgfTtrrfVTNgNNfrt
+dFDWCDdFppvDFmWWWnJTPllHmHlgrqrgggtH
+DzFbWjdRpbdFCjjRbnFbQBGhhQBBJZwMhScwZwJz
+HttvHpHmpJWtHmFNvlvdMSVdPMtLVCCMMMfcfL
+GjgzhGSGSSdCcRMVjMdc
+QshbnghgnGDnqsFrNSJFrsNs
+wJpjMwzjzdVbzPPVpbCHnqGnBqnsBrNCwgrC
+ftTLLDTQtLTGTGtFrgHrvqgQnrvQsCHH
+fTcFFfLSfFFcGFllcFhPJPjWWJSjSWzMWPdS
+ZjNdmjVQVZmvNNZNNZHWZmWtsJnwTpJJswpWwGqJhJqGpp
+FcRRcDblDMLRcRMLFFMDGsJnqhwpqTTJGwnsfnlp
+LRBrcLbbgLFgBbFqDvdHQvCCjNzzzVrZdV
+BdbLWrgdvgWvVJgWnDfNhVnqhCCpDpcq
+tSQPSTSGPMmlMPtQQPJGtGQRCcnqqfnRhCcChDqnCfRScf
+jTssPsjMQMmszPjlTtsJdFBFrJzrbJdHZFHdWH
+vCccctvvTTtZcgLGcZTbssbMWnpMpmLWqnNjpfPPfPjMPp
+wwBBlRBBwDDVFRhFlRhdRRVWPnnpMpffmmffrpWqVNPm
+ddhddRzHlQHFJcGsCztTgbNzST
+fJctfpVWcnfRLfrRwP
+vmmnvDQDZTNTmGGTqTMTvMqwBdLjBvRzBRrRBRLjjBPzBB
+GMnmqSTFFQqttcbcJWgsSt
+rHNfmfRsmfRGfDNcRmcmMQlLCGSnQwwPPCSnzQlSCl
+bsJTBsVhFsVpqFWFgPCwnQwBZzwQzZLlzn
+qggTTqvqgqbbTTFqVqgWqvNmmMMRdffftNfMDMmscR
+rFWQFszrwjsjFWvshPTCmLZLSTLwSLlgSP
+BQbcqVHNVqVpVpmClJgJJHSmZLJm
+qBNNNVdDMGBpDcDWsvdQsFrFnjttfj
+qGhmttmzhtMvhbrLdSHbdSHRzb
+WCBgQJJpjCQlgdHZrfPRPSRbNg
+jBTTDjlnjnJDJTQCVntcwtwMSvqcGFDhcvsh
+ZTrnTqMWWWnfrddMGJPgPLlPbw
+VvmGRVpBpNNmvNvjVjtpNpCNLLLJHHBdgLPdwsdsbLlwwlwb
+GmCVSCRVGmpCRVvttmpDrQZfhnzhzqnDWnrZZTQq
+DQBZHHtWHzSvZvDQWchgqsqqhrrhhcqrcZ
+jdMfwlFfFlTfndwpjjwGnNrqhPTmPSPTPPhmgrPSrh
+jlGbwGMdlnJpGFGjpnFCSJzzDDtWHCBBQBvtVC
+RrbBWBRRWSRsBBVvsPHZDwSjjPdnHwtPtH
+fTgfzMmNJpmJgfllgpjVQtDDndVQpdnHVtPp
+gGmlNclTGmGFhLVcVrvLqrvc
+QcpCTVCZVcCwLcCVvHvvVsCcNzNNSbPRzsDRDSBlsNNzDRtb
+fggMfJqgrWFpmjWMggmrfMWNSbRSPBDbNtJRtPJzlStBbN
+gdnmpWGnZvdQCvdv
+tqqcLqqDDqNtDrqHrrPWlTlTWZTMzTFzQlMPSZ
+pfnpmmppmppRGjwbjmnjwspWbQQQTMWZbCTSZCSQlCllZF
+gmpVnGmmmpjDvVLBFqqvrH
+LqBvJHZvbHGBHrBtGGQTmSVprVzhpVPDPQzQ
+CRdRgwCfhTVDzSdQ
+fRCcjgSMjfNgMMLGbGZtvBbGHv
+HgvtDDzDpvwgvvqdHPZWdMssTTddSs
+rJFrGNFVQmNFVmRnWhhsrTbhwhZTrdTd
+VQGBBBVNQClpcBvBwD
+PWlSzZGmdmGmlGmhggBpvMjvMjFgPJ
+TtLRDtQQfTVcQQQRtBsJFFccFjWhJJFMBs
+HqVCNtWHCDwdnlGwGqSr
+RwdRJgCJRGGmdMbcGbdnTnTtttLLnptMtMtMqZ
+DWsWPFrPqVPPLVCB
+zQWWsslsQHFhDSszDSFQzJJJmvcgblRgmNvCJmvNgw
+tpmFrWTtRpRTtggsSlnQpsnnlSHPsn
+bZwZjNNZGLSrVsGndPPV
+NvrcjCfbvvLBDBWfWFgRRm
+WWFMgWmMhhwDcMMMDcmLWLtQwwsjbsQHvZHbRjZfsZzH
+PTCplTCdSJJCpvPGNSvsbsfHtbQZzdHjQtjjsj
+vNGJPpqJvJvqghgFgWFmLD
+RlRpLTZCjWRjRWwpRsjHjbSbqMqMvvnbnGMnGGqQCq
+gddfDNczmgPthNcDdgPVnbbzbnJrJJGSSVJJQS
+BmDmcDmcmhffdBHlRwjRLpwlWQ
+prQlfzlWRPzgQWzlMPMRppssHHsDsHjwnHHbWDwwbwjL
+vFBJJtZNShJvZFtdSqtmqjTDVHVGDHbwVHDVsDnThH
+vcjBZZdZqvCfpzRfcgRp
+cggpqgRlSpNsgNggbjjj
+ZZSSJVLVLFDZWNGjCWWbCjsF
+vZLvfZQQfQtJVJDQShLrLfMmnldmwqwTqqMcMTMTndrm
+bQBMtBPddtMFbJFhRGzMfzvnRGRSvWnW
+TmHTqlVHwVpQqjmwGvSgSpnLpzfWGWSn
+TTrDQCDrrTmDCCCVHHQZBdZFPdsNdFBtFDhtFB
+fjpQvNZcGhGGTtQS
+DVJzvbVmHbbtSTSTRStzTM
+VDvmqllmJfjWlnplNs
+ZmdHZJjvQLdRjpmLJrqqZBhhtCschPfBPcrDfPffCD
+MWWSMMwnwlSgzWFFgSwzVwzqcfDCfChCbbtssbfDChcD
+NMqFTwGqMwgwwgjHRdHRjdmQmQTm
+TTqWPCWRhTWqPNjPJMNtrlbJFttQwwrBrlbwlc
+GfpSDGZvpQffSHDgggDZrHctFmrHncnnwwbBtBrt
+SQGfLsSLZsqMTRNMPT
+HdBdnBZJTZBBmsfwwBlh
+MjCVjzwqWrfzplzW
+vVbqCjjRgjwMbnbGHJScScZHLL
+dwwwtCdznvDDFrMrrw
+GmWLQmgQmHgcdGcsTgTDqDbSfFWfMDMfbSNqvr
+QhTLmVQHLmdLTjGGVptRnZpZBZVRpPpP
+CzjFpzRHdtBFBCqNqSbJZWcQJTSbQjMTWZ
+wGwVLlGrdVGwDnwsgfMSZvJMbWJcWlvbbMSc
+rDfsgggrGnGngsPwdVLfDnmDtzzFNCPHtzCtFHpBRqhPztzR
+mrgWzBcDtVCcQcCCdscf
+LRJhjRjPZvqSRGhGjLgMCdHpMNwQCpMHpHMS
+GRvGJRJjqPZbvGGhRjnqLJWtgFgtzTzDrFnTWrlTlllW
+cbmcddlffvbTfvFflpZzsMVNznNVlnqnzqHMNM
+StWJBQRWLRWNPNMCswRVHC
+BJQBhSWhjSthJQGGWWggJDDDfbdbbfHbddbrFrddvFvv
+jFqvqvWZWDtBJrrlrq
+TzGcbHcrmVzMGNSmTcGDtBthJCNtsJDlBCghgP
+bTrnTccnLSrrTHbnwfLjfdvRRwZFdwfR
+drHVrdVDfsDbVsdVDbVqRwbZZwCRCCCJlJThwRgT
+jFPcFpBSvtNPzSFcjcQpcQjpThZCRltGRRRJhwCwGhwgwhRm
+SQSzPBjjPPSvLqqssdnqLZLMsM
+bQTWlWlvQclNwwWlCCLStCRSSjStpj
+zVZZDdBnBmgzVsjsLthSpshdCL
+DfBnrmBmgzHBfDHmnGrNFCwQvTPvqCTwqTFGbF
+srSWJnrbmlWlbhzsWszSvPGwvgDhcjdjjfvhjvGv
+BRRQFLtNfQNMpqpQHDjdDjDcZZcvwZZHPH
+NLCNCtRQfRttRFRCTqMBqQQrzrbzrlJmVVbsSWmVrTbSzJ
+RHLfLcSRTFSghLRHGbwZmMZddgJswZsbMm
+ptqjtCzzQztqCjDlBGpDpbMZdwmMbZsdwNmdJpbs
+tttzCVllDCtDQnQBVHGHWvWTLWcLSLHf
+FVlNnPqbGTHftghggJqf
+zLcZWZpWWrcrZLLZDWrwMcrhBFBttChBmBgptChhtFftmf
+LZZLrDrrDDMrcwrDwsWFzdTlnGQPQQVbdbnsvnvsVQ
+BbPNMJNbQvDbvPLwHflczlwwzf
+pZjWZGZjFGdgpnVgZhghdmcflrlswzzcstlrLwhtwc
+WZSdqFjqSqSWdGFjZpdMTTDNTvLCRRLLqRQMCN
+FqgFGtbgTvRwrLqhvw
+JCCWJWCdJMQNNsSWsMPQRDDLDSDLwTrrvnwfDvnD
+HdPJlBBHCCQdBMWdTtVbgHczGVGjmtzG
+PLlZDLZDsFCvbDQv
+HVcTmVmJqVzqczfzbjvvCFMRfCsWjMvR
+cqHzTqJTTTTzzmnmrctrBlLlvSlgLdZvSwSlpw
+SbMMNJjmgMnJdSSbjVFZVSQrlQfWVQVWZh
+PtqDqPGcLHzHpqLcRzRsfQFfZlfRfZfRFVsl
+cTDLcqGCzDTqzzDLDzqPTtJvbBJMnmvjbdlmJNvmdgNC
+tDJDlZVqJGbvHNQbNFFsFPmLns
+ppczpzpffGwfBNLGmn
+WShzgTTpWzhWztJJGJSvtvvtjq
+TbZFTFScnCZFQRTCqQdBjdJqjBqjjQDB
+rmmLpLLfzrlmslMBHvdRddNDDJDrqD
+MWwLPzmWfpsMmmlMPMWLwRTZTZnnTcVCcZFCwSnZ
+SqmClqHssNWCqPTcWcGhBTchVV
+ZnnnDflRpBVTTVhPBZ
+DpgfvnvMfCsqlMtSll
+ZzLMRZpLMwwppZqnQGvQgBSvlNVlBFFNFVrg
+HcqhTmhmdDTPFTJgTTFBSgJN
+mccPdDDHbssbtwZMqpbzCRGM
+TgqnTltgWqLRSRnlqddngFfrvHvrBTfCCFrFVTvVCf
+cwNJmPzQwNzczzNsJGhhHfhrfvVHGvtvVVfC
+jjtbtDswcmPWlbgRnRdMZL
+TmpTBBwvspTptRmsmTGLQDGRHGgVGLSQSMHQ
+ZlPWqjWrzjPqdrlzbrbrwfrWLHVMLnHDMVDQnLQfQfVngQLS
+zNwbrrFWbFJpmpmvvt
+RMQQMwHMMzcFsWsDrWfcpJpS
+LLhZmGVLhVlTZfWWfWpCrDsGSp
+VLVTnqjjZngtQRFjvzDM
+gmRBpjrpRvCfRCrBgvjHShnbnngbgSJnNsHMHS
+ZDPTwGWtqwHhSnbcMNJw
+DWGGqtVVqldWZzMzWmvjrjprLRFjRVvvff
+tCzVzsVtDFzssnSsgdqJdCNqJhmgmpqq
+PZccPGvQfRLMQwNdhpwhNh
+jLrcbRjPZBrcPdjRHFlWnVtBFslSWznW
+vvvbJbWrLvFWHzZzZRhB
+chtwTmCNlRRZzRPT
+hmcCssCswrMDGMSrsr
+LStGBsQLlllhzMzs
+dzVZDNWRDdZNDTZTPvWVhhphpMlfMccRmfnlMlRn
+VFvgTrNPdFWNNFNFTzTFFSjSQBCqrtQwSBGLLBGwGL
+qGJSJhWStdSfWvSvtGRRnzRDDggrgvnzsmRP
+lTTLpcljjGlLlLNBpjwFQDQmRnrRDPrPscRrDDng
+NCNjFlHNCTVjpwGqGSVbJddqZZJM
+MbWdgvHFlMvmzTzShvmm
+tqjqpLsNsrrsjstNLpQrGVhVBzrhVcfmchDcTPVVmc
+RqwjqjqsGjjGGQNjGpQZpqRFJgmMHwdbFWgnHMFdwmmCFW
+HHHLcCcVHjTHglsB
+wDSRwzzRpMSdNSPSwSpRbqvgBsdqlgTvBFBjgFvvgB
+RpbzPssDMWwNRbRNRPDsDhJthLQVGLJcctQCJQfQJCLm
+WsZgbNgZVCCWbVVVmgZbCCRPccGnzPBqJjzWJBJPzvBvGz
+SpfThHtrHFBPPzJvPntj
+QHDhhrhpTQpHhQHnfwnTCNlbZCCDLNllZlVsNCNl
+QtzJFRQLMRnZcZsfcphlPQ
+qSBbjmWSCNmVldSqqSqmjCSZshfwfrPPZZfcPVZfhgsgPg
+HqBbHqBGSlNBbltnLLHFJMtRvRTD
+tcGtDdMcttttHNBlMctldlwjwwqqCLCwDwZjFCZhmnwC
+VrJgvWWsPvRgVgrJQvfQfzgVzZwCbLZmnmwCwZqmnhjZbnLj
+sJpffsRWWRJVWWpHltSpnMHGcMTl
+zNqRbqSbfdcTLLfS
+ZVPzPnVvdLwLDPfF
+VWnzQCVWZVMzQRHgqgqrHGtGMp
+PbHpWfWPvRfbzWPFfRpPDtBwSHMwCBgDwBjDtMMM
+hTTdZQlcnTcmqVTdcddrDgBSwsjjBgqBtsCgMD
+hlldTmdJJmJdZvzfFfNJFJgRzR
+PJWvJBbWsfLQWsLvmCqHCcNLHqHLLcwDqV
+dQztrZrdwHhptqDH
+ZrMGjgMSrdzQGQRJPvGGbm
+RmjljZChlDZBCRRvlmNSLSqMNLzwLvppwQSQ
+sTnVnPrVGsGTPddJrfgQgqLgGpMNQtgNtNzg
+sbbTfTdcJPnHbsJfHsdcmDDmmqBZlClmjBRDCZ
+CJmHLmHFFCFbHsbJsJqvqhQqLDhQZvnQDZnn
+wGwppTjdWPdgFpGcScBqNnNqNhQlDqnDlZZW
+pGcgGgTpGjFdwpSFVgSdpPjrMCMffzJzRzztRfHCRsVmtbsz
+CgBClZfCflPflNZRvfQswwmwmwQsQhgppdhm
+qbzDGrjLLNLDHDqtJmmhhmQdhwpQhhbp
+NLGqVqjDjjGrMFrvFWPBRBZnCvfFnT
+tbrrHsgsVmmmbtgwVsQRqjJMmqMjQfJfLFLD
+ZvlBGzdvjGfRFJQJ
+dBppnnBBhdzZncBPlznpnNdWHSsbWthbSCgHrVfgSSwVgr
+VRvMtRVFHQLvMRQFQtBctrthshTTgCmhTrgWhWZsZZ
+lzJlGBSPPhzjgZsTCr
+wJlpJPfDSpwBnddqJDdpPpcvMFHFMvNbvnNMFHHRVVbR
+CPShbbdlGCdQqlRPGPdlDWDFzjtFjggCDJgWczfF
+mrHrTrrBMBsmNsrwsBpnfpggDDcjjDDpjzFJzzjtJz
+BvsNvBLHrrrNvwBTNNsNGbdQhlPGGfqhhRGqLGdl
+PSSlPtlStGhPNMtwPMPJzDddnbnDNTDDnJqjbz
+FFVHRwVLvFvVrVHrZcLmRHggjDmdDnDnznnznzQjzdmJddbn
+WrvgRgcRcRrrcRvgcVrHVrwCCSfsCsGsllhMSSSSMttlSCpG
+hBPJqVZTqqPSlGlfddfddZvl
+JWWMJCpnMrmztzdjnzld
+RbWsrwMrpbRspbWgpwhLJPccNVqLLPSVgVPV
+hcTrWqcfhwGfWrWMjHjGvDHPmJMDzF
+ZtlsnZZtLBSbSssnbndjDJJFHFHJPHPsHMTHHM
+ntRZtSbtZgZStTqchwQfRwNpcq
+GfLqrsqQGgPgjjQGVcNvTpTpNFcWPvPPpT
+bRnRLnMZFdCMcpvT
+RnRhzRlmlhhHhhmhRsqLrfzrGVSrGBSGrL
+fbMffwdZsncrGcfG
+qDBjSSLqhLBSmDbjqNhqTLjCGrCHGrvcGWcpWcrGWnCrpm
+STLDqbhTLqNTNSRhlwZlJlRQFFRwMdPQ
+TVVGNFggcjPPJzwvQlRRwRvSlcSc
+frsBbWhtSRzSLfRf
+qDCqddbsWrqzhsdNmdJNJHjTggFFVV
+NTWTDrSdFTLtPTGf
+lZqjHlVRvRltLtRWFMtFLL
+qvjWzzvVbZpjqllggscdchwDrCphwsdhrD

day03/src/main.rs

@@ -0,0 +1,83 @@
+use std::fs;
+
+fn main() {
+    const FILE_PATH: &str = "input.txt";
+    println!("Hi this is the third day of AOC2022, first we will read the file {}", FILE_PATH);
+    let contents = fs::read_to_string(FILE_PATH)
+        .expect("Should have been able to read the file");
+
+    println!("The sum of the priorities is: {}", &contents.lines().map(|l| get_priori(get_repeat(l))).sum::<u32>());
+    println!("The sum of the badges is: {}", get_groups(&contents).iter().map(|g| get_priori(grup_repeat(g))).sum::<u32>());
+}
+
+fn get_priori(c: char) -> u32{
+    let priori = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    priori.find(c).expect("must be a letre") as u32 + 1
+}
+
+fn get_groups(s: &str) -> Vec<Vec<&str>>{
+    let mut out = Vec::new();
+    let mut lines = s.lines();
+    loop {
+        let mut grup = Vec::new();
+        if let Some(line) = lines.next() {
+            grup.push(line);
+            grup.push(lines.next().expect("what"));
+            grup.push(lines.next().expect("Wharrr"))
+        }else{break;}
+        out.push(grup);
+    }
+    out
+}
+
+fn grup_repeat(grup: &Vec<&str>) -> char{
+    let mut repeated = Vec::new();
+    for c in grup[0].chars(){
+        if let Some(i) = grup[1].find(c){
+            repeated.push(grup[1].chars().nth(i).expect("should have failed before"));
+        }
+    };
+    for c in repeated {
+        if let Some(i) = grup[2].find(c){
+            return (grup[2].chars().nth(i).expect("should have failed before"));
+        }
+    };
+    return panic!();
+}
+
+fn get_repeat(s: &str) -> char{
+    let slen = s.len();
+    let s1 = &s[0..slen/2];
+    let s2 = &s[slen/2..slen];
+    for c in s1.chars(){
+        if let Some(i) = s2.find(c){
+            return s2.chars().nth(i).expect("should have failed before");
+        }
+    };
+    return panic!();
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    #[test]
+    fn it_works() {
+        let input = r#"vJrwpWtwJgWrhcsFMMfFFhFp
+jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL
+PmmdzqPrVvPwwTWBwg
+wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn
+ttgJtRGJQctTZtZT
+CrZsJsPPZsGzwwsLwLmpwMDw"#;
+        assert_eq!(input.lines().map(|l| get_priori(get_repeat(l))).sum::<u32>(), 157);
+    }
+    #[test]
+    fn it_works2() {
+        let input = r#"vJrwpWtwJgWrhcsFMMfFFhFp
+jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL
+PmmdzqPrVvPwwTWBwg
+wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn
+ttgJtRGJQctTZtZT
+CrZsJsPPZsGzwwsLwLmpwMDw"#;
+        assert_eq!(get_groups(input).iter().map(|g| get_priori(grup_repeat(g))).sum::<u32>(), 70);
+    }
+}

day04/Cargo.toml

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

day04/src/main.rs

@@ -0,0 +1,55 @@
+use std::fs;
+use std::str::FromStr;
+
+fn main() {
+    const FILE_PATH: &str = "input";
+    println!("Hi this is the fourth day of AOC2022, first we will read the file {}", FILE_PATH);
+    let contents = fs::read_to_string(FILE_PATH)
+        .expect("Should have been able to read the file");
+
+    println!("The ammount of subranges are: {}", contents.lines().map(|l| get_ranges(l)).filter(|t| ranges_contain(t.0,t.1)).count());
+    println!("The ammount of overlapped ranges are: {}", contents.lines().map(|l| get_ranges(l)).filter(|t| ranges_overlap(t.0,t.1)).count());
+}
+
+fn ranges_contain(a: (u32,u32), b: (u32,u32)) -> bool {
+    !((a.0 > b.0 && a.1 > b.1)||(a.0 < b.0 && a.1 < b.1))
+}
+
+fn ranges_overlap(a: (u32,u32), b: (u32,u32)) -> bool {
+    !((a.0 > b.1 && a.1 > b.1)||(a.0 < b.0 && a.1 < b.0))
+}
+
+fn get_ranges(s: &str) -> ((u32, u32),(u32, u32)) {
+    let mut out = s.split(",");
+    (get_range(out.next().expect("There must be something")),get_range(out.next().expect("There must be a second elf")))
+}
+
+fn get_range(s: &str) -> (u32, u32){
+    let mut out = s.split("-").map(|n| u32::from_str(n).expect("Must be a number"));
+    (out.next().expect("There must be something"), out.next().expect("There must be a second number"))
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    #[test]
+    fn it_works() {
+        let input = r#"2-4,6-8
+2-3,4-5
+5-7,7-9
+2-8,3-7
+6-6,4-6
+2-6,4-8"#;
+        assert_eq!(input.lines().map(|l| get_ranges(l)).filter(|t| ranges_contain(t.0,t.1)).count(), 2);
+    }
+    #[test]
+    fn it_works2() {
+        let input = r#"2-4,6-8
+2-3,4-5
+5-7,7-9
+2-8,3-7
+6-6,4-6
+2-6,4-8"#;
+        assert_eq!(input.lines().map(|l| get_ranges(l)).filter(|t| ranges_overlap(t.0,t.1)).count(), 4);
+    }
+}