diff --git a/day_2_part_2/Cargo.toml b/day_2_part_2/Cargo.toml new file mode 100644 index 0000000..170376e --- /dev/null +++ b/day_2_part_2/Cargo.toml @@ -0,0 +1,9 @@ +[package] +name = "advent_of_code_2022" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +rfd = "0.10.0" diff --git a/day_2_part_2/src/main.rs b/day_2_part_2/src/main.rs new file mode 100644 index 0000000..63ca488 --- /dev/null +++ b/day_2_part_2/src/main.rs @@ -0,0 +1,74 @@ +use std::collections::HashMap; +use std::fs::File; +use std::io::{BufRead, BufReader}; + +// struct play { +// them: str, +// you: str +// } + +fn main() { + + let current_path = std::env::current_dir().unwrap(); + let res = rfd::FileDialog::new().set_directory(¤t_path).pick_file().unwrap(); + let book = File::open(res.as_path()).unwrap(); + + + let reader = BufReader::new(book); + let mut complete_score:i32 = 0; + + let scores: HashMap<&str, i32> = HashMap::from([ + ("A", 1), //rock + ("B", 2), //paper + ("C", 3) //scizzors + ]); + + let lose_options: HashMap = HashMap::from([ + (1,3),//scissors lose to rock + (2,1),//rock lose to paper + (3,2)//paper lose to scissors + ]); + + let win_options: HashMap = HashMap::from([ + (1,2),//paper beats rock + (2,3),//scissors beat paper + (3,1)//rock beats scissors + ]); + + + for buffer in reader.lines() { + if let Ok(line) = buffer { + let unparsed_play = line.split(' ').collect::>(); + complete_score += calculate_score(&unparsed_play, &scores, &lose_options, &win_options); + } + } + + println!("total score = {}", complete_score) + + + + +} + +fn calculate_score(current_play: &Vec<&str>, scores: &HashMap<&str, i32>, lose_options: &HashMap, win_options: &HashMap) -> i32 { + let them:i32 = scores[current_play[0]]; + let mut score = 0; + if (current_play[1] == String::from("X")) { + //lose + let mut score = (0 + lose_options[&them]); + println!("current play:\nthem: {}, \nus: {}\nscore: {}\nformula: gamestate {} + option {} = score {}", current_play[0],current_play[1], score, 0, lose_options[&them], score); + return score + } else if (current_play[1] == String::from("Y")) { + //draw + let mut score = 3 + them; + println!("current play:\nthem: {}, \nus: {}\nscore: {}\nformula: gamestate {} + option {} = score {}", current_play[0],current_play[1], score, 3, them, score); + return score; + } else { + //win + let mut score = 6 + win_options[&them]; + println!("current play:\nthem: {}, \nus: {}\nscore: {}\nformula: gamestate {} + option {} = score {}", current_play[0],current_play[1], score,6,win_options[&them], score); + return score; + } +} + + diff --git a/day_3/Cargo.toml b/day_3/Cargo.toml new file mode 100644 index 0000000..be6ecf7 --- /dev/null +++ b/day_3/Cargo.toml @@ -0,0 +1,10 @@ +[package] +name = "advent_of_code_2022" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +rfd = "0.10.0" +substring = "1.4.5" \ No newline at end of file diff --git a/day_3/input b/day_3/input new file mode 100644 index 0000000..d0ad78f --- /dev/null +++ b/day_3/input @@ -0,0 +1,300 @@ +PcPlnShmrLmBnmcwBhrmcmbHNGFGpwdFFwGNjNbGqNHH +tzQfRJfWZZztWzVtCTfRzFZjpFjNZjGLHbdHLDdjpb +CCQTzRLzvQVVfRzJfMPsnBlglgPmBgPmvSrl +RMfvbbszHTsssFPzDQPggpQJPQ +NSNcqVtLVGgDlpQBClVB +hmStGNNLhjNrpWLGSjWrZssbZTMMvTfMnThbRRTs +fTrTPGTbfftWBBmLjrJL +DqHwVMqVplDslmlZmpHVwNnShWZFdBBdjWBtWtdtWJSSLS +MNslpDvVHlwsmpQRgQgCfTTcvcRQ +pBBhRgDsMsswprBhvgRglZtFGFFRqZtZmRtNqtZPPN +TdmmzzmdZdqdGFtF +nmSccCVmSCpDCswMwl +NptqDsQtDTQzCvlzCpRlRp +jmZcndmjbZcjrmDvFMFFlwCvzFnF +jjgLVLrGcdDBNhWQTgHg +mLVhhfSMSTmMwClHGdpjDHjGdV +zPrZgJCgbsnrPtZzsCsbpRDjBRHnjGDRldRHppcG +JJrbsFrZqrgWbbqbrgWzJPNTwhTNCmmvfWCShhhmwwfm +ftgfljvgfgBTNvtggFDDGLGRDnMDzcQzncGt +VdbpbVdZwdwrsVVLRrMrDLDBGnBGcM +wmpWwWsHWBCCCPPvjvmSqlfTTmSNgN +jSqmzmmSSDRjLMLDwqjNcMMLTTflffWCCsRsTHnHVrfHWTsr +tdbgZpgBPdgGZGGFTHVpCsCVfVsJpnWl +FnPQFvbvhFFFbvBwScjhzcqSLLSzSN +bWdgrWwwFWbgzFWzrmNbdPqttChMSRnmqSPSnqtMRM +lcPJLDDPPfpMBCRJBtQtMh +lGDGjTGLLDHPPGjlPTsswsbHNFsNrFNFsrzr +VmtHfVhBLHVtlhphjZMdnQQZZqZmQDdzQQ +CPFwPWrvWgrfNgFPCMqZzMDDbznFTqqzDQ +NNPsfffPCsBLjpVltV +ssdBBJqJhlTJLsjTJqFFmnmmnnrcmpprmmmPcRlf +gqtqzSgWQWqmnRPPcNmmQM +GqbSVtGzvgvgWbZjjBhTdhBsTZBJBZ +jhNBsPDzLjsVhLSNzgvcvbcwbBWFcgtWCc +ZQQTTHHnGpMtnpdHpQJfMgrvWWFqbcWWGgrgwCCwwF +nHpmMnQQMmHpRnHRmMJnnTShPzljzjSNmSDhLsNSPtSh +GdqnBGFdlqzFnwdSCQZjZLLDZjZRvZLDVvgQ +PsptsTcftMfcTfhTghVDvvjnRNjVZnvV +WtPfJTfftJcMTrMnpccFwlCSCGFGCbCwJSbqBl +GjFLGhjRwFjNSjSdJCBBdQJddbBc +MVvMMHRzVtHlvlcQBQJHqdpQqCBC +vDgVztvvmrgrVRrMmsrsmZzZnWhGnNhGWTLfnLwTLhLTjngL +VljjQJSsrjjrCglsCjsgjVVfDLdZGMdvvGdQMzmvzcDQMc +HqPBtcpRWwtHbbFwBHZfmfpDfvffDfMfmGvM +PwHNbcwtqFqnwtNNqPNPPWBTThjhhVTCSJTThssVnSlJJV +GCccNCrrnCrpnzrnCDPcDDrvHHTBqTPhswqhPTBTTwBhTj +VfNmRtZgWWHdBdswdjZv +SmtQfgNmVFgVLVLVmrnMpcDLGCGLGDMpCp +CrdZdZmPPjrQdRPRDqDLBqBLBSWgWgLDzF +sQhTNphsVbhhhMJfhNVGqltVSzSllBzStlzFFFWB +hsMpwQhNMZmPmrwHRj +cNVpSVRpLHRLsVWWfnfsCshW +jvqjTgqZPlJZmbPPfbpswsPb +vlqdTZdtJvqdZjgqZrtRpQFtLFRQczHGzt +JJQndVQnQgTfNvGf +ljpbWbmNbDlGTvggGvZf +mpmRbMmmNDFDmScpzCsdzrnJrsCzrrnM +tNFtNFFzzjjzjBtVNZVbjZGlpSvTllpWwvnBlWGGBGCC +fPdcrrgPHrHMMMWlppGJSPwGSnGv +fmrqrhhfhdRddHrhQqQrfnLZjLtNttZjjRtzjFtRNj +sphRcpQRhfmnmfpptg +WVPlGLlSjCjSlGSHJJWZdmbmfvPmmnftbbgDdt +LJjjqVNjlnCTRcRhhsNcFF +vwwqttFjwgClRNCCvGNmZZMmJsPJjJpTdMpsZd +fBLVHHHrFnhHhnrVSTmfdPdPccTTPsMfsJ +QzVWzznzFbWNGNlt +vjMddVVmnWpdMndjvhhWfNLpfBsfLLZLBBSqqTZq +RFlrzQJPSRGzzzzgBZNsgBZTBflfgf +cQFDRHFDDGCJShCnvwVnnhCn +hgjlpRRLlPJJhTLJMDnwBndSPBNvMqnN +FGWVfZsmCbmVzrvtwCSMtMdnDMCw +VsVmVZfVQDmVFrrmzmGrHHTJgJjhHJcllglLQJRL +rrTVcTBgsjTffmfWHZTv +JLdnDlpGlGSLlpwJpHZfFvRZnWzWrHWqFH +wQDpDrdSlSCblCdwdSLlwQGBthPMsghNsVNVtCNNhNPjhs +CtCMvNhDMHfDDdffqtDtCflpJlBpvmWWJWwlpwFFvjwB +rGSbVGZrSsFJjlmBFZWp +rbbQgzVGrFVSPPGqfhftfqztNtqHtt +lMGZCGphllZDNshNNmHHND +PLwjVwJVsHmRrZZw +ffSdzjfZSjtjSjLtLLFFFGqFzznCpCnCBblQ +CqRnlzHCRWTlHPTZVQrcQtFsQFTcrQ +DfJcdBDBcftQjsrsBtjZ +JDfdGhSvNGhNfffGSfRznPvcRWcqCqmlvlcn +JPhBBBQCnCJCMhnhMZRrRZgbDgrWrNbglDgR +jLtSTwtsShwRNpRWrh +FLLSHsjGLGczvfPfJdfhddnHPC +BjHBNrWmTjFgJngbJhWd +vsGttMDtwCMQCJnqqqFJsggqdg +GFtDSwwMpTrzSSfcfm +rnWDQvpwWpDDcPjFPPHZjVDZ +CTJCRmCJcZZZHCCQ +LdlmdQJNpnLWbrfL +VdTdcVTZwCRGVGGMVmttlF +gnrsbngfgQSpBfpMBBBpSgMNNJbmGmlqGDqDNlFFJlGNFz +gprgQhgpMMMPsrRTCdPZwCwZZCRH +cHlCVGbbWHWqRNThhcNcmh +MwQDzpwdJwpBpPDQvrhShfLTTRLfLdjfNRqS +JwMBBrPsPDwQMDPPBPQJwMrvWHFbHHlgbsGnnWHnFnRGlblF +PQPjPDjRRQSFLSlgSmLlfh +zpLdBddbNCdqGbWJGWpJWWlsFsmmFpwfflFgfHwFhgmh +nJLdLVnzqqbjRctcPDQVTP +JdztScztPdSWLJLtgMbCjhvlbPRbjbMvCh +VZrqfQcFQwGVVFqfrTFTNqhljRHDMvMMGhRDRRHGbDhG +NZQNVQQpQmrZFQQFwQQVVZgBszJJgznstnmtcztdBSgs +nFHLNJzFbLJGGLMlTTRZbZRhWRTr +wVmgBBmtmwlqlWTwTM +sdvmgcPsCPPQQSMz +SccCqmQmgBmppLQmpSMjjlJzzsNPMDRbPNPlJM +VHZvwtZwhZHtdTwrVbNsljlRDlJPDhzsbN +dZwftVRftmcgpBCmBf +NTTlVlgNSflqbphFFhNbFp +wmmLmjwzwbWGLjRmtZZdhZLFtQQLQBFh +RvjbMjjvMzMWbDWwvzPjvmWSfVfsTlVVPVgTgPfVsnnnsJ +BsBsZHZNdWwsNdrzgCrMMqsjzzMC +flfhVWFmLrhQzCCh +fVbmFSpnSSmtnPZvdWbwvdvdHZ +NsZWWWWLsBZPhfsLmPhcFCCHCMMrqfqcvHMfHH +nThSllnplGlMpvFRcCqrrr +DnTwSztgzlDnVGTwztmdZhmLdJdNDshBdsWs +RBBGTFZGglMHvrtcgSdnNgjg +DmVcbmbJmwJDJzVVwzJfmfstnztvjnNjvNSpdptvzCnpjj +DsLcfLmbhVQssQJQscWRPBZZMMRLHFHZBGMG +FVvhVnhFnFhmvFhVcMBHLgcPClrqqrtqCppldrRRTppldg +QLWfDNwsQLtlrrCtDdpq +sJwZwLsGJWGGwzzWZNbWNLjQHSVhvHSnhcMFcbVmnvcchSBS +jTMNMrHBJWWDffRqfDBqfD +QmSFphtQqQmVmqVnPnPlpwgfnRnDPl +VqFmLFbLhmZhGFGmCmGtZLtJWzWHcJrNrHMccjMscMHzMZ +hGPGmbfPzbPfgdMdWGqBGQcqpp +nvFTvDrTdNZZlrjnMHHHpBBcppqq +rNlZZNLvRdRCRFFwZwhgbmSJPSmPfhfwhS +vjdbFWTtFRRvtvZZvdWJWbGjLhCcnrrrNqLNCPqchShNqc +QHQVlDsMfmmDMHDBdLdCSLnhNLNNfqCd +VQHsMDpHlzMBBwlsmMzmmlVwptvTWdvJdbvJtRTWgGFJJGtR +nSScBcnbbFSQVdBFBtWpwtvtPbTZthtTvT +pRzHpGjCDGzHGCGsThqqwZwPhCtvhTqZ +NzlzjDDpNldBFrlfFQ +qJlDlPPWppgppqPlplpfdvgnbMfGbdgCghMdCM +QWTWZcSsWbvVvTnhfC +tRFLwZrcrWzzlJmtBqlm +HMNMvvzzNcmfNmfbhs +qVcwCgjCLtWRSLsTPbmPfmTh +RtWCJgddWRtCJdWWgdBjwWWwpzMFpHGprcBGFFnGHQZHQGpF +gZgBDgDVGDGjmDZRtgjvVvtQdnLrcRcrdfdfCcnlscsJsn +WTqzqHqNzpHpwzNhMHNwWPbQCQcCLsnCrLLfcrffNflcNn +zHTwwpTPzTTwlFTFzwqzPbwZGgGZZBtmGGvGmBGZVFStFZ +znlSSzfzTcmmfcCt +PHWWGpqgPShPMwGwqJFTVtwtCVTCmTJcFc +qHqqSggLrRLBbvDDdndzRQ +WBddBQWZWWQqqQFMWfmrWsJnmVJJNDDVJGsLmHmLDN +PTgCjvCCPPPzSZGJVLsVZCHHnH +pzwtPTvzTjRTPtwSjPSzRgBbWMBfMwwZfbWrMrZFqFFM +BqDwVqdqlDlblQMf +ZcCWWcWzvJZjcPjZZZfTHfQJQHThqpMbQQJf +LPCcZcczZLgCjvPWgvstjsjmRRBdmGrdGdmSFGnFrtGmqr +CBvgQssVzfCBQSgvvvfmrlGrCtMGwthJlJtbrh +TpLqLRFpqdRpRTfNPtRmrMMtMlMMmlMJlt +PZTjqFFTHZZNZpqcVWzVvgzcWnSWfBDD +SVSTpgpVpdNbpcVdfjcNfbcJnqsltcJPvRJqRwQqlQsJls +zhWzDLmFHhmrWZmmzHJJQlnswqsvttrstQqs +zGtZFGGCmZmGGFhLBWBGGFdgVjgppMTSTgMfCNfVVSdj +CzjNJGcnzQJltPHttcPHTP +bLVsqLbLmSSVrqmdhVSmsVFFprfrFWrwTTWWWZpFPtlP +ssDsMqLqhvmvhdmdvzRCnQgRzzBjgnlNCM +TzTLzzSGRlRSjWzlWRzHGTpNhPhJPmdnNPPbhlbPbdhfPh +mBCDBVrCqVQvQMBcVcqBrBDsbtJfnZNbJndNNhthZNJfPZPs +wMCrqVvBzmzHTGLw +NbfwfZPPdVNPdBdQBcmQzrQz +nnWqHLWGFMDFDLDjsqnHLsrQGzmJczmQrgJmJGZmQrgJ +FFWRsHMHCZCWFwRwphpvlfTTpp +PclPlVZvLDNvVZSLSMvvDttmtfzFtzHqtqtzzccCFc +jrggQGhjQsTDbrbJjJQqzzCsdtzzFCdHqmBBHz +WGDgngwrQggZMNvMWPMRRV +wNgpMdMMcdSscccNcLLTbtQJtQJQltJwFtlBlzBt +HHGhrLrCvHWHCPhrWDtnBllnQbfQftGnfnBF +HvLjWCLHPZvHHHZjjrqVTTZVcppMgNNNNSpS +QQrwQmvWQjgTfvBjfffrSDcrqSqDDVLctqqcVd +GnHFnGhGplGMlHMNhzBzlLPLVcVNCPDqVNdcqLdqtV +GnMGpslMhGsRzzHzGsZFZQJTTmWfBbvfgfgJRfbwbW +MRCtSwMhvjCGtvMZDVWpVZJlVccNDlpb +gdLQFFwwLfHJWnQlcJJbWc +rdqdmqHLTLmsswsFHLFtMPRMCSSRtSjTPMPSCR +jmCCnLCLZjZjRjQTLZQhGPGhhzHhDRGRDzwzwh +stlJlrlJJcSSfSMMzPfhhGhzpwhpNwhD +rbrbBcSlWmdZWjDnTm +PNBRNnnqQRNfVfRtVVzgFLLttpSwgzzzmFFF +fcWlcbvvCFzLbwLw +rlrMrhTJhDcTTfhRNqHRQPQRQNQB +TrprpprRVVfpRpVqTVpzDdvmvbbCchhcttqcthSMdd +JlnZnFlsMBZnJHlsLsCLbSNtbNhdbbShCScm +FlZjjsHHsnQFQwTDzMRRpGRR +wHWzwCTTqJhzzvJhWHWhqJWrFsFQrrrFCfFfgjjgjprfsp +DBRmZRtZLbnRBGSBmtGSLpjBrrsfrgsTQVrVrrPrgr +DLnbcbtLtmNNmbRcGbcGmHzlThNNhqJTHdvqvWlHJh +GSNqjRcqflNLnCTTWrWn +BmwQtmtJwPwmzMwQtHtVssvrnpWTTnsTTgpVCLCs +DBBQHJJrzhzQDDfSljRfhccfcdZf +wtgtChCwzqgLzjggqtHtjFHHFcnPfdRDfZZVcPfVZZfGnfdm +vBTrRTTWGGmcTDVD +SJMbbpWslJblSSNzNsztRChzqRCj +gBHHCtVCSHMQlfFTQqCfmq +WrpdwjbwbwQGlPqSqblP +wWDncWrDDNdWNRjScScjpzvHZtBMZtJsvLVgvzssBsvs +VppWpVfmZPBlnmrGBzhttMzMpctLLcChSh +FwgLJvRdHcwMzSzjzc +QvbgdQLQgDvsqvqRHRDdDQDBWmBGBflnVbZmZmmnBBWrmW +SqShwLFCQGpDHCtZCWpW +bdHPHjTbJdsMnPHPbdjgtnBlVlBnVgtZpDBpWV +bdmPcjbjMNMvvHbTcQRNfRwRwLffwwqwNF +zdRHTpQTQHQnpnnQRHTsNNlJSJWmzJmJllNmSG +FBbRvLbFRwLqbbVgBVqqLFqJtJNcltsSGmgmGtNtgWmstm +FLhhfvvVwvjqfLRBqLVqbwqZQrTTpHMHjdrpnnDPDQCdCrpC +JgjzvbJCWgbjgGbJWjRhgNPGHHBMtqBStZZsHMSsBqtD +cfQdwQFdQQppnVVnlFLLBsBZMhqPlPMMqBSHDtHM +wnQhcnVddmdWgjvjmvRjjJ +QpcRtndvsLcVJtRSzWSlWjzSbjjWBv +qGZPqCTmGPqgGTCqHgCqZCPFWbbBNBMNBbdBMlWWrbjlMbFl +qhHDGhCmPhZHgDmDVQthttRchLwLdwcc +srpPMwlMmsrGFGswvDRhRWRDJJJchJ +fSgBbCBNnBTTgCNLTCRJhRJVWhTcVVVFFJdR +SbBnnLNZCLFQCZjnCnZFjPrzqmlMmmsrpzrlsmtt +BBsfDfsBDSWRwlLqmWCpWcllrl +nQMgMnnnhdntgMBrCdpNNLNlNqLqLl +FnQFHzPQJjJGRBGvfR +lRnVRFFlgMCRVwLgFZRnZQHWdcftHdmcJHmmMdzzfz +DGBqGQbhhBDbSBpGDBzqdNHJdtmcWdqdmtcm +bjbsBvjhSlVsPRgLQl +dDLbRdTMRJMbFRzZBfzNSjtNBzBD +PmgspqqVrppTVrvrsPhhfQwZBwNjNtNffzqqfwwN +mCcmsngrPvpVTssCVsvsPLRRJllGFlnRGbMJMWWlJJ +fGlGZHRRbwgPbZRRNCdcSWpncnQtQWlWcWpW +JrTLJgVvVLQQvtSvQncQ +JrrrmMTBVTmjBMrVjrshmJzgCfzRPCRZPGHfbwNPzbZHNH +qqqlDDZzVVnNqHDDFFFNlQpzjrTvsvzTbgJQQggjJp +cWPWcCmMfCMWdtPMhMbQQQjGGjpdvjTbjgjr +WtMSBCtCwchChMfBWtcPnNVNqZZLDRNqTRnnlwHn +mvQQnhBvhmvBmncmZBclTZTQccRFNFFdqFFgVqSRrgFrppNR +MjzJPzGPfffMCjVVjfPHLCFRNFStqrdRSdqdNGRqNptq +HDJHPjDJLfjbzfwPjCzCWWTwlmQhBnsWBvVsvBvZ +RVjcshhscQhrVjhvzjVfDNnzGtftmDHFttFGGf +qLcBCCMBJJbTdBDnNtdfnmDG +WpZgLLclTclRwgjgsrwsvj +shhhltNPcDtlNcNMcsctNtppLZvWWFLTFFZpTZDQgFLT +dRgJVzRHbqnLpTWQvLLJfp +mCVCdzqHndbqHCrVqRrmbwtNBsmPwNmScPgtPhBclw +bDDZMDrFPsrsMcsrbJZJdMMGpSzpSbwRSSRGpCHCGzlhCC +BWWNQjBLQVHhlGpSCmwj +ffwnNwfgtnNgVVwfNWBWnFsMJTJTcPFJcTFDsrJstJ +vQbQLQBpBvbvpHplHNTHWGZDngntZCQGgZhGhtjG +rqccPPmcrffRmsmCjVgnrGChChDjgW +fqRJsJMSlSzSWTbT +brsjjJPJwrJJsrRRlllNQGWQpwppCtfGGtWzGGMQ +ncBqqLTDnmLgVDZVnBDmdtVVtMzWWdMCQdpQWdVz +hDZgTSSnTzNPNFSFPF +VZVJJtWTsfTVVWsJhPWrCjzSBJlHSmjJCRlNSSlz +CqMpwccgvvgLnvLbMMRRjBNHzjmGmwNHlmlN +gLqqvpCDfVDrTfVW +CNMDGNPPNJCGbLnTffsTLT +tcBBRlrBdQrtmtWFjjbnrTjjFbjr +cTQQhcmvcBRcwDMVDZZPPCJh +mBCdgPLgZmLfGmfvGhtRQJWjtjQGQhtN +pMwrVwbwHMsqcTWQhQWzggTTWp +nnSMwrlrsmSZgvvmDd +WNSzpCzNzqzNdmqrRHrrLHFrJH +MtPfvnGMPnMcbnRtDHTRFFDrmJRQ +PcBsfPPHPGGfcSzZjNjpNZZdCs +mDCZVLDhWVSDCRvGtsGgGRHl +JjPwPNdcPnjPdcwNltHzzGmgGJzQJJRQ +dqfjnNmwmbmWrZMbMrThhB +qtBpNZFpBGFNfZNPmZPmQmHrmPPPTz +LLwJLvDvlWWLHdwDrVcCRcDVzzVVcV +sMMwvgjnMvjvnlsvNFBqfGHFqHGjtSpS +MmZZsFgwJTdTMdgmZdZRgFhDHhPQPPnRPhCrHhnnrPDD +fBcLlNNpQCDLDJJC +jSbWWlWpBpclWlWpNWlVBbWVdgwswFJmFJsGtdMggZFGbZwd +CMVQVMLLMFGRCMWQttnqqwQwhqsm +pJzlczSpPpPgmsqNhmPGDstq +gZgTccZGGpzdpjclGRVMVRFRMFvHRLRdLf +FMWMSBtStZqZWQtFtScWWSZmHPVJJVHwwlTgmgbzQwbwTJ +jhGLhdjNjsLvLsshzHJPVdVmmbzHzdHJ +jvDRNjnDNGRCzjLzZZpqnrFBSccWrMcB +zggmthDDghHvtrdgrVWfSBRwTHLWHwsBWw +PGGjpCjQnJQGJcJnnQpjFWVSsZWVLRZLBcsWSZBRWS +FGQlpnJCbqqGGRCjjnlCqGMtdNmmmvdNmmmzvhbrmgMz +TstvBTdgBhqTsdTcPlfCSrNMrNnrCNNSNNgp +HwLQwQDZzDjnDbmMhNSnmm +FZLVzLLQHRRzwWHjdPlJctlJtlsllhRs +fBtPsMDDswHvBmmVdBlSBRcGGnhVhg +LWJbrpFqpTLTTjqqNWlhnRGGSnhrcSdlRlsh +JWNbbpjJzTbNNNJNJMvmvfZHvzDsHDCsZw +LPGnPNLtwGhFFnJPfsqpVVszzpsP +TcWdvlrcWddggrDBDDdDMmWzRJqfVQZqmsfZsRQzZfZzQJ +TldWrMrDdlDCDdMTcwSLVCSShLNSwHjhGF +JGsWWWQsJmPwQWbBPmccbcbqFfMMpFDVCDFVFVCDqqfFwD +ZtLnlvLnNtvLndnCmfMVSmVCClfpVp +zTzZtjnZNLNmZvdtznntHHZJbBRGBRQWcJGbGsbsJRPQWT +MLmlMTPtQtMNlhbqbbqhflBB +rcrvjpSvScbRbBvbDBPG +ZZJzSHpzPrJzHFmMVMFmHCLNtV diff --git a/day_3/src/main.rs b/day_3/src/main.rs new file mode 100644 index 0000000..2b6cd9e --- /dev/null +++ b/day_3/src/main.rs @@ -0,0 +1,43 @@ +use std::fs::File; +use std::io::{BufRead, BufReader}; +use substring::Substring; + +fn main() { + //A = 65, Z = 90, a = 97, z = 122 + let current_path = std::env::current_dir().unwrap(); + let res = rfd::FileDialog::new().set_directory(¤t_path).pick_file().unwrap(); + let list = File::open(res.as_path()).unwrap(); + let reader = BufReader::new(list); + let mut counter :u64= 0; + for buffer in reader.lines() { + if let Ok(line) = buffer { + let first_half= line.substring(0,line.len()/2).as_bytes(); + let second_half = line.substring(line.len()/2,line.len()).as_bytes(); + for char in first_half { + if (second_half.contains(&char)) { + // println!("{}", (char % 91)); + // println!("{}", char); + if ((char % 91) < *char) { + + + + let temp = u64::from(char.clone()) -96; + + println!("{} is in both parts, LOWERCDASE", temp); + counter += temp; + } + else + { + let temp = u64::from(char.clone()) -38; + println!("{} is in both parts, UPPERCASE", temp); + counter += temp; + } + + break; + } + + } + } + } + println!("complete score is : {}", counter) +} diff --git a/day_3_part_2/Cargo.toml b/day_3_part_2/Cargo.toml new file mode 100644 index 0000000..dc84c19 --- /dev/null +++ b/day_3_part_2/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "advent_of_code_2022" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +rfd = "0.10.0" + + +substring = "1.4.5" diff --git a/day_3_part_2/input b/day_3_part_2/input new file mode 100644 index 0000000..d0ad78f --- /dev/null +++ b/day_3_part_2/input @@ -0,0 +1,300 @@ +PcPlnShmrLmBnmcwBhrmcmbHNGFGpwdFFwGNjNbGqNHH +tzQfRJfWZZztWzVtCTfRzFZjpFjNZjGLHbdHLDdjpb +CCQTzRLzvQVVfRzJfMPsnBlglgPmBgPmvSrl +RMfvbbszHTsssFPzDQPggpQJPQ +NSNcqVtLVGgDlpQBClVB +hmStGNNLhjNrpWLGSjWrZssbZTMMvTfMnThbRRTs +fTrTPGTbfftWBBmLjrJL +DqHwVMqVplDslmlZmpHVwNnShWZFdBBdjWBtWtdtWJSSLS +MNslpDvVHlwsmpQRgQgCfTTcvcRQ +pBBhRgDsMsswprBhvgRglZtFGFFRqZtZmRtNqtZPPN +TdmmzzmdZdqdGFtF +nmSccCVmSCpDCswMwl +NptqDsQtDTQzCvlzCpRlRp +jmZcndmjbZcjrmDvFMFFlwCvzFnF +jjgLVLrGcdDBNhWQTgHg +mLVhhfSMSTmMwClHGdpjDHjGdV +zPrZgJCgbsnrPtZzsCsbpRDjBRHnjGDRldRHppcG +JJrbsFrZqrgWbbqbrgWzJPNTwhTNCmmvfWCShhhmwwfm +ftgfljvgfgBTNvtggFDDGLGRDnMDzcQzncGt +VdbpbVdZwdwrsVVLRrMrDLDBGnBGcM +wmpWwWsHWBCCCPPvjvmSqlfTTmSNgN +jSqmzmmSSDRjLMLDwqjNcMMLTTflffWCCsRsTHnHVrfHWTsr +tdbgZpgBPdgGZGGFTHVpCsCVfVsJpnWl +FnPQFvbvhFFFbvBwScjhzcqSLLSzSN +bWdgrWwwFWbgzFWzrmNbdPqttChMSRnmqSPSnqtMRM +lcPJLDDPPfpMBCRJBtQtMh +lGDGjTGLLDHPPGjlPTsswsbHNFsNrFNFsrzr +VmtHfVhBLHVtlhphjZMdnQQZZqZmQDdzQQ +CPFwPWrvWgrfNgFPCMqZzMDDbznFTqqzDQ +NNPsfffPCsBLjpVltV +ssdBBJqJhlTJLsjTJqFFmnmmnnrcmpprmmmPcRlf +gqtqzSgWQWqmnRPPcNmmQM +GqbSVtGzvgvgWbZjjBhTdhBsTZBJBZ +jhNBsPDzLjsVhLSNzgvcvbcwbBWFcgtWCc +ZQQTTHHnGpMtnpdHpQJfMgrvWWFqbcWWGgrgwCCwwF +nHpmMnQQMmHpRnHRmMJnnTShPzljzjSNmSDhLsNSPtSh +GdqnBGFdlqzFnwdSCQZjZLLDZjZRvZLDVvgQ +PsptsTcftMfcTfhTghVDvvjnRNjVZnvV +WtPfJTfftJcMTrMnpccFwlCSCGFGCbCwJSbqBl +GjFLGhjRwFjNSjSdJCBBdQJddbBc +MVvMMHRzVtHlvlcQBQJHqdpQqCBC +vDgVztvvmrgrVRrMmsrsmZzZnWhGnNhGWTLfnLwTLhLTjngL +VljjQJSsrjjrCglsCjsgjVVfDLdZGMdvvGdQMzmvzcDQMc +HqPBtcpRWwtHbbFwBHZfmfpDfvffDfMfmGvM +PwHNbcwtqFqnwtNNqPNPPWBTThjhhVTCSJTThssVnSlJJV +GCccNCrrnCrpnzrnCDPcDDrvHHTBqTPhswqhPTBTTwBhTj +VfNmRtZgWWHdBdswdjZv +SmtQfgNmVFgVLVLVmrnMpcDLGCGLGDMpCp +CrdZdZmPPjrQdRPRDqDLBqBLBSWgWgLDzF +sQhTNphsVbhhhMJfhNVGqltVSzSllBzStlzFFFWB +hsMpwQhNMZmPmrwHRj +cNVpSVRpLHRLsVWWfnfsCshW +jvqjTgqZPlJZmbPPfbpswsPb +vlqdTZdtJvqdZjgqZrtRpQFtLFRQczHGzt +JJQndVQnQgTfNvGf +ljpbWbmNbDlGTvggGvZf +mpmRbMmmNDFDmScpzCsdzrnJrsCzrrnM +tNFtNFFzzjjzjBtVNZVbjZGlpSvTllpWwvnBlWGGBGCC +fPdcrrgPHrHMMMWlppGJSPwGSnGv +fmrqrhhfhdRddHrhQqQrfnLZjLtNttZjjRtzjFtRNj +sphRcpQRhfmnmfpptg +WVPlGLlSjCjSlGSHJJWZdmbmfvPmmnftbbgDdt +LJjjqVNjlnCTRcRhhsNcFF +vwwqttFjwgClRNCCvGNmZZMmJsPJjJpTdMpsZd +fBLVHHHrFnhHhnrVSTmfdPdPccTTPsMfsJ +QzVWzznzFbWNGNlt +vjMddVVmnWpdMndjvhhWfNLpfBsfLLZLBBSqqTZq +RFlrzQJPSRGzzzzgBZNsgBZTBflfgf +cQFDRHFDDGCJShCnvwVnnhCn +hgjlpRRLlPJJhTLJMDnwBndSPBNvMqnN +FGWVfZsmCbmVzrvtwCSMtMdnDMCw +VsVmVZfVQDmVFrrmzmGrHHTJgJjhHJcllglLQJRL +rrTVcTBgsjTffmfWHZTv +JLdnDlpGlGSLlpwJpHZfFvRZnWzWrHWqFH +wQDpDrdSlSCblCdwdSLlwQGBthPMsghNsVNVtCNNhNPjhs +CtCMvNhDMHfDDdffqtDtCflpJlBpvmWWJWwlpwFFvjwB +rGSbVGZrSsFJjlmBFZWp +rbbQgzVGrFVSPPGqfhftfqztNtqHtt +lMGZCGphllZDNshNNmHHND +PLwjVwJVsHmRrZZw +ffSdzjfZSjtjSjLtLLFFFGqFzznCpCnCBblQ +CqRnlzHCRWTlHPTZVQrcQtFsQFTcrQ +DfJcdBDBcftQjsrsBtjZ +JDfdGhSvNGhNfffGSfRznPvcRWcqCqmlvlcn +JPhBBBQCnCJCMhnhMZRrRZgbDgrWrNbglDgR +jLtSTwtsShwRNpRWrh +FLLSHsjGLGczvfPfJdfhddnHPC +BjHBNrWmTjFgJngbJhWd +vsGttMDtwCMQCJnqqqFJsggqdg +GFtDSwwMpTrzSSfcfm +rnWDQvpwWpDDcPjFPPHZjVDZ +CTJCRmCJcZZZHCCQ +LdlmdQJNpnLWbrfL +VdTdcVTZwCRGVGGMVmttlF +gnrsbngfgQSpBfpMBBBpSgMNNJbmGmlqGDqDNlFFJlGNFz +gprgQhgpMMMPsrRTCdPZwCwZZCRH +cHlCVGbbWHWqRNThhcNcmh +MwQDzpwdJwpBpPDQvrhShfLTTRLfLdjfNRqS +JwMBBrPsPDwQMDPPBPQJwMrvWHFbHHlgbsGnnWHnFnRGlblF +PQPjPDjRRQSFLSlgSmLlfh +zpLdBddbNCdqGbWJGWpJWWlsFsmmFpwfflFgfHwFhgmh +nJLdLVnzqqbjRctcPDQVTP +JdztScztPdSWLJLtgMbCjhvlbPRbjbMvCh +VZrqfQcFQwGVVFqfrTFTNqhljRHDMvMMGhRDRRHGbDhG +NZQNVQQpQmrZFQQFwQQVVZgBszJJgznstnmtcztdBSgs +nFHLNJzFbLJGGLMlTTRZbZRhWRTr +wVmgBBmtmwlqlWTwTM +sdvmgcPsCPPQQSMz +SccCqmQmgBmppLQmpSMjjlJzzsNPMDRbPNPlJM +VHZvwtZwhZHtdTwrVbNsljlRDlJPDhzsbN +dZwftVRftmcgpBCmBf +NTTlVlgNSflqbphFFhNbFp +wmmLmjwzwbWGLjRmtZZdhZLFtQQLQBFh +RvjbMjjvMzMWbDWwvzPjvmWSfVfsTlVVPVgTgPfVsnnnsJ +BsBsZHZNdWwsNdrzgCrMMqsjzzMC +flfhVWFmLrhQzCCh +fVbmFSpnSSmtnPZvdWbwvdvdHZ +NsZWWWWLsBZPhfsLmPhcFCCHCMMrqfqcvHMfHH +nThSllnplGlMpvFRcCqrrr +DnTwSztgzlDnVGTwztmdZhmLdJdNDshBdsWs +RBBGTFZGglMHvrtcgSdnNgjg +DmVcbmbJmwJDJzVVwzJfmfstnztvjnNjvNSpdptvzCnpjj +DsLcfLmbhVQssQJQscWRPBZZMMRLHFHZBGMG +FVvhVnhFnFhmvFhVcMBHLgcPClrqqrtqCppldrRRTppldg +QLWfDNwsQLtlrrCtDdpq +sJwZwLsGJWGGwzzWZNbWNLjQHSVhvHSnhcMFcbVmnvcchSBS +jTMNMrHBJWWDffRqfDBqfD +QmSFphtQqQmVmqVnPnPlpwgfnRnDPl +VqFmLFbLhmZhGFGmCmGtZLtJWzWHcJrNrHMccjMscMHzMZ +hGPGmbfPzbPfgdMdWGqBGQcqpp +nvFTvDrTdNZZlrjnMHHHpBBcppqq +rNlZZNLvRdRCRFFwZwhgbmSJPSmPfhfwhS +vjdbFWTtFRRvtvZZvdWJWbGjLhCcnrrrNqLNCPqchShNqc +QHQVlDsMfmmDMHDBdLdCSLnhNLNNfqCd +VQHsMDpHlzMBBwlsmMzmmlVwptvTWdvJdbvJtRTWgGFJJGtR +nSScBcnbbFSQVdBFBtWpwtvtPbTZthtTvT +pRzHpGjCDGzHGCGsThqqwZwPhCtvhTqZ +NzlzjDDpNldBFrlfFQ +qJlDlPPWppgppqPlplpfdvgnbMfGbdgCghMdCM +QWTWZcSsWbvVvTnhfC +tRFLwZrcrWzzlJmtBqlm +HMNMvvzzNcmfNmfbhs +qVcwCgjCLtWRSLsTPbmPfmTh +RtWCJgddWRtCJdWWgdBjwWWwpzMFpHGprcBGFFnGHQZHQGpF +gZgBDgDVGDGjmDZRtgjvVvtQdnLrcRcrdfdfCcnlscsJsn +WTqzqHqNzpHpwzNhMHNwWPbQCQcCLsnCrLLfcrffNflcNn +zHTwwpTPzTTwlFTFzwqzPbwZGgGZZBtmGGvGmBGZVFStFZ +znlSSzfzTcmmfcCt +PHWWGpqgPShPMwGwqJFTVtwtCVTCmTJcFc +qHqqSggLrRLBbvDDdndzRQ +WBddBQWZWWQqqQFMWfmrWsJnmVJJNDDVJGsLmHmLDN +PTgCjvCCPPPzSZGJVLsVZCHHnH +pzwtPTvzTjRTPtwSjPSzRgBbWMBfMwwZfbWrMrZFqFFM +BqDwVqdqlDlblQMf +ZcCWWcWzvJZjcPjZZZfTHfQJQHThqpMbQQJf +LPCcZcczZLgCjvPWgvstjsjmRRBdmGrdGdmSFGnFrtGmqr +CBvgQssVzfCBQSgvvvfmrlGrCtMGwthJlJtbrh +TpLqLRFpqdRpRTfNPtRmrMMtMlMMmlMJlt +PZTjqFFTHZZNZpqcVWzVvgzcWnSWfBDD +SVSTpgpVpdNbpcVdfjcNfbcJnqsltcJPvRJqRwQqlQsJls +zhWzDLmFHhmrWZmmzHJJQlnswqsvttrstQqs +zGtZFGGCmZmGGFhLBWBGGFdgVjgppMTSTgMfCNfVVSdj +CzjNJGcnzQJltPHttcPHTP +bLVsqLbLmSSVrqmdhVSmsVFFprfrFWrwTTWWWZpFPtlP +ssDsMqLqhvmvhdmdvzRCnQgRzzBjgnlNCM +TzTLzzSGRlRSjWzlWRzHGTpNhPhJPmdnNPPbhlbPbdhfPh +mBCDBVrCqVQvQMBcVcqBrBDsbtJfnZNbJndNNhthZNJfPZPs +wMCrqVvBzmzHTGLw +NbfwfZPPdVNPdBdQBcmQzrQz +nnWqHLWGFMDFDLDjsqnHLsrQGzmJczmQrgJmJGZmQrgJ +FFWRsHMHCZCWFwRwphpvlfTTpp +PclPlVZvLDNvVZSLSMvvDttmtfzFtzHqtqtzzccCFc +jrggQGhjQsTDbrbJjJQqzzCsdtzzFCdHqmBBHz +WGDgngwrQggZMNvMWPMRRV +wNgpMdMMcdSscccNcLLTbtQJtQJQltJwFtlBlzBt +HHGhrLrCvHWHCPhrWDtnBllnQbfQftGnfnBF +HvLjWCLHPZvHHHZjjrqVTTZVcppMgNNNNSpS +QQrwQmvWQjgTfvBjfffrSDcrqSqDDVLctqqcVd +GnHFnGhGplGMlHMNhzBzlLPLVcVNCPDqVNdcqLdqtV +GnMGpslMhGsRzzHzGsZFZQJTTmWfBbvfgfgJRfbwbW +MRCtSwMhvjCGtvMZDVWpVZJlVccNDlpb +gdLQFFwwLfHJWnQlcJJbWc +rdqdmqHLTLmsswsFHLFtMPRMCSSRtSjTPMPSCR +jmCCnLCLZjZjRjQTLZQhGPGhhzHhDRGRDzwzwh +stlJlrlJJcSSfSMMzPfhhGhzpwhpNwhD +rbrbBcSlWmdZWjDnTm +PNBRNnnqQRNfVfRtVVzgFLLttpSwgzzzmFFF +fcWlcbvvCFzLbwLw +rlrMrhTJhDcTTfhRNqHRQPQRQNQB +TrprpprRVVfpRpVqTVpzDdvmvbbCchhcttqcthSMdd +JlnZnFlsMBZnJHlsLsCLbSNtbNhdbbShCScm +FlZjjsHHsnQFQwTDzMRRpGRR +wHWzwCTTqJhzzvJhWHWhqJWrFsFQrrrFCfFfgjjgjprfsp +DBRmZRtZLbnRBGSBmtGSLpjBrrsfrgsTQVrVrrPrgr +DLnbcbtLtmNNmbRcGbcGmHzlThNNhqJTHdvqvWlHJh +GSNqjRcqflNLnCTTWrWn +BmwQtmtJwPwmzMwQtHtVssvrnpWTTnsTTgpVCLCs +DBBQHJJrzhzQDDfSljRfhccfcdZf +wtgtChCwzqgLzjggqtHtjFHHFcnPfdRDfZZVcPfVZZfGnfdm +vBTrRTTWGGmcTDVD +SJMbbpWslJblSSNzNsztRChzqRCj +gBHHCtVCSHMQlfFTQqCfmq +WrpdwjbwbwQGlPqSqblP +wWDncWrDDNdWNRjScScjpzvHZtBMZtJsvLVgvzssBsvs +VppWpVfmZPBlnmrGBzhttMzMpctLLcChSh +FwgLJvRdHcwMzSzjzc +QvbgdQLQgDvsqvqRHRDdDQDBWmBGBflnVbZmZmmnBBWrmW +SqShwLFCQGpDHCtZCWpW +bdHPHjTbJdsMnPHPbdjgtnBlVlBnVgtZpDBpWV +bdmPcjbjMNMvvHbTcQRNfRwRwLffwwqwNF +zdRHTpQTQHQnpnnQRHTsNNlJSJWmzJmJllNmSG +FBbRvLbFRwLqbbVgBVqqLFqJtJNcltsSGmgmGtNtgWmstm +FLhhfvvVwvjqfLRBqLVqbwqZQrTTpHMHjdrpnnDPDQCdCrpC +JgjzvbJCWgbjgGbJWjRhgNPGHHBMtqBStZZsHMSsBqtD +cfQdwQFdQQppnVVnlFLLBsBZMhqPlPMMqBSHDtHM +wnQhcnVddmdWgjvjmvRjjJ +QpcRtndvsLcVJtRSzWSlWjzSbjjWBv +qGZPqCTmGPqgGTCqHgCqZCPFWbbBNBMNBbdBMlWWrbjlMbFl +qhHDGhCmPhZHgDmDVQthttRchLwLdwcc +srpPMwlMmsrGFGswvDRhRWRDJJJchJ +fSgBbCBNnBTTgCNLTCRJhRJVWhTcVVVFFJdR +SbBnnLNZCLFQCZjnCnZFjPrzqmlMmmsrpzrlsmtt +BBsfDfsBDSWRwlLqmWCpWcllrl +nQMgMnnnhdntgMBrCdpNNLNlNqLqLl +FnQFHzPQJjJGRBGvfR +lRnVRFFlgMCRVwLgFZRnZQHWdcftHdmcJHmmMdzzfz +DGBqGQbhhBDbSBpGDBzqdNHJdtmcWdqdmtcm +bjbsBvjhSlVsPRgLQl +dDLbRdTMRJMbFRzZBfzNSjtNBzBD +PmgspqqVrppTVrvrsPhhfQwZBwNjNtNffzqqfwwN +mCcmsngrPvpVTssCVsvsPLRRJllGFlnRGbMJMWWlJJ +fGlGZHRRbwgPbZRRNCdcSWpncnQtQWlWcWpW +JrTLJgVvVLQQvtSvQncQ +JrrrmMTBVTmjBMrVjrshmJzgCfzRPCRZPGHfbwNPzbZHNH +qqqlDDZzVVnNqHDDFFFNlQpzjrTvsvzTbgJQQggjJp +cWPWcCmMfCMWdtPMhMbQQQjGGjpdvjTbjgjr +WtMSBCtCwchChMfBWtcPnNVNqZZLDRNqTRnnlwHn +mvQQnhBvhmvBmncmZBclTZTQccRFNFFdqFFgVqSRrgFrppNR +MjzJPzGPfffMCjVVjfPHLCFRNFStqrdRSdqdNGRqNptq +HDJHPjDJLfjbzfwPjCzCWWTwlmQhBnsWBvVsvBvZ +RVjcshhscQhrVjhvzjVfDNnzGtftmDHFttFGGf +qLcBCCMBJJbTdBDnNtdfnmDG +WpZgLLclTclRwgjgsrwsvj +shhhltNPcDtlNcNMcsctNtppLZvWWFLTFFZpTZDQgFLT +dRgJVzRHbqnLpTWQvLLJfp +mCVCdzqHndbqHCrVqRrmbwtNBsmPwNmScPgtPhBclw +bDDZMDrFPsrsMcsrbJZJdMMGpSzpSbwRSSRGpCHCGzlhCC +BWWNQjBLQVHhlGpSCmwj +ffwnNwfgtnNgVVwfNWBWnFsMJTJTcPFJcTFDsrJstJ +vQbQLQBpBvbvpHplHNTHWGZDngntZCQGgZhGhtjG +rqccPPmcrffRmsmCjVgnrGChChDjgW +fqRJsJMSlSzSWTbT +brsjjJPJwrJJsrRRlllNQGWQpwppCtfGGtWzGGMQ +ncBqqLTDnmLgVDZVnBDmdtVVtMzWWdMCQdpQWdVz +hDZgTSSnTzNPNFSFPF +VZVJJtWTsfTVVWsJhPWrCjzSBJlHSmjJCRlNSSlz +CqMpwccgvvgLnvLbMMRRjBNHzjmGmwNHlmlN +gLqqvpCDfVDrTfVW +CNMDGNPPNJCGbLnTffsTLT +tcBBRlrBdQrtmtWFjjbnrTjjFbjr +cTQQhcmvcBRcwDMVDZZPPCJh +mBCdgPLgZmLfGmfvGhtRQJWjtjQGQhtN +pMwrVwbwHMsqcTWQhQWzggTTWp +nnSMwrlrsmSZgvvmDd +WNSzpCzNzqzNdmqrRHrrLHFrJH +MtPfvnGMPnMcbnRtDHTRFFDrmJRQ +PcBsfPPHPGGfcSzZjNjpNZZdCs +mDCZVLDhWVSDCRvGtsGgGRHl +JjPwPNdcPnjPdcwNltHzzGmgGJzQJJRQ +dqfjnNmwmbmWrZMbMrThhB +qtBpNZFpBGFNfZNPmZPmQmHrmPPPTz +LLwJLvDvlWWLHdwDrVcCRcDVzzVVcV +sMMwvgjnMvjvnlsvNFBqfGHFqHGjtSpS +MmZZsFgwJTdTMdgmZdZRgFhDHhPQPPnRPhCrHhnnrPDD +fBcLlNNpQCDLDJJC +jSbWWlWpBpclWlWpNWlVBbWVdgwswFJmFJsGtdMggZFGbZwd +CMVQVMLLMFGRCMWQttnqqwQwhqsm +pJzlczSpPpPgmsqNhmPGDstq +gZgTccZGGpzdpjclGRVMVRFRMFvHRLRdLf +FMWMSBtStZqZWQtFtScWWSZmHPVJJVHwwlTgmgbzQwbwTJ +jhGLhdjNjsLvLsshzHJPVdVmmbzHzdHJ +jvDRNjnDNGRCzjLzZZpqnrFBSccWrMcB +zggmthDDghHvtrdgrVWfSBRwTHLWHwsBWw +PGGjpCjQnJQGJcJnnQpjFWVSsZWVLRZLBcsWSZBRWS +FGQlpnJCbqqGGRCjjnlCqGMtdNmmmvdNmmmzvhbrmgMz +TstvBTdgBhqTsdTcPlfCSrNMrNnrCNNSNNgp +HwLQwQDZzDjnDbmMhNSnmm +FZLVzLLQHRRzwWHjdPlJctlJtlsllhRs +fBtPsMDDswHvBmmVdBlSBRcGGnhVhg +LWJbrpFqpTLTTjqqNWlhnRGGSnhrcSdlRlsh +JWNbbpjJzTbNNNJNJMvmvfZHvzDsHDCsZw +LPGnPNLtwGhFFnJPfsqpVVszzpsP +TcWdvlrcWddggrDBDDdDMmWzRJqfVQZqmsfZsRQzZfZzQJ +TldWrMrDdlDCDdMTcwSLVCSShLNSwHjhGF +JGsWWWQsJmPwQWbBPmccbcbqFfMMpFDVCDFVFVCDqqfFwD +ZtLnlvLnNtvLndnCmfMVSmVCClfpVp +zTzZtjnZNLNmZvdtznntHHZJbBRGBRQWcJGbGsbsJRPQWT +MLmlMTPtQtMNlhbqbbqhflBB +rcrvjpSvScbRbBvbDBPG +ZZJzSHpzPrJzHFmMVMFmHCLNtV diff --git a/day_3_part_2/src/main.rs b/day_3_part_2/src/main.rs new file mode 100644 index 0000000..b689d4c --- /dev/null +++ b/day_3_part_2/src/main.rs @@ -0,0 +1,41 @@ +use std::fs::File; +use std::io::{BufRead, BufReader}; +use substring::Substring; + + + +fn main() { + let mut elfBuffer: Vec = Vec::new(); + let mut value: u64 = 0; + let current_path = std::env::current_dir().unwrap(); + let res = rfd::FileDialog::new().set_directory(¤t_path).pick_file().unwrap(); + let list = File::open(res.as_path()).unwrap(); + let reader = BufReader::new(list); + for buffer in reader.lines() { + if let Ok(line) = buffer { + elfBuffer.push(line.clone()); + if (elfBuffer.len() == 3) { + value += parse_elfs(elfBuffer[0].clone(), elfBuffer[1].clone(), elfBuffer[2].clone()); + elfBuffer = Vec::new() + } + } + } + println!("{}", value) +} +pub fn parse_elfs(elf_a: String, elf_b: String, elf_c: String) -> u64{ + for char in elf_a.as_bytes() { + if elf_b.as_bytes().contains(char) && elf_c.as_bytes().contains(char) { + return convert_value(char.clone()); + } + } + return 0;//nothing found + //TODO when nothing found make this throw an err and catch the err above +} + +fn convert_value(value: u8) -> u64 { + if (value % 91) < value { + return u64::from(value.clone()) -96; + } else { + return u64::from(value.clone()) -38; + } +} diff --git a/day_3_part_2/test.txt b/day_3_part_2/test.txt new file mode 100644 index 0000000..9919ffa --- /dev/null +++ b/day_3_part_2/test.txt @@ -0,0 +1,6 @@ +vJrwpWtwJgWrhcsFMMfFFhFp +jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL +PmmdzqPrVvPwwTWBwg +wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn +ttgJtRGJQctTZtZT +CrZsJsPPZsGzwwsLwLmpwMDw \ No newline at end of file