push for pushing sake

day2/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "day2"
+version = "0.1.0"

day2/Cargo.toml

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

day2/src/main.rs

@@ -0,0 +1,96 @@
+use std::fs::File;
+use std::io::{prelude::*, BufReader};
+
+#[derive(Debug)]
+struct HoHoError{}
+
+#[derive(PartialEq)]
+enum Choice{
+    Rock = 1,
+    Paper,
+    Scissors,
+}
+
+impl std::str::FromStr for Choice {
+    type Err = HoHoError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "A" | "X" => Ok(Choice::Rock),
+            "B" | "Y" => Ok(Choice::Paper),
+            "C" | "Z" => Ok(Choice::Scissors),
+            _ => Err(HoHoError{}),
+        }
+    }
+}
+
+impl Choice {
+    fn cmp(&self, opponent: &Self) -> i32 {
+        if self == opponent {
+            return 3;
+        }
+        if self.beats() == *opponent {
+            return 6;
+        }
+        0
+    }
+    fn beats (&self) -> Choice {
+        match self {
+            Choice::Rock => Choice::Scissors,
+            Choice::Paper => Choice::Rock,
+            Choice::Scissors => Choice::Paper,
+        }
+    }
+    fn loses(&self) -> Choice {
+        match self {
+            Choice::Rock => Choice::Paper,
+            Choice::Paper => Choice::Scissors,
+            Choice::Scissors => Choice::Rock,
+        }
+    }
+}
+
+struct Game{
+    pub opponent: Choice,
+    pub you: Choice,
+}
+
+impl std::str::FromStr for Game {
+    type Err = HoHoError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let str_split = s.split(" ").collect::<Vec<&str>>();
+        let opponent: Choice = str_split[0].parse()?;
+        // game1
+        //let you: Choice = str_split[1].parse()?;
+        let you = match str_split[1] {
+            "X" => opponent.beats(),
+            "Y" => str_split[0].parse()?,
+            "Z" => opponent.loses(),
+            _ => return Err(HoHoError{})
+        };
+        Ok(Game{opponent, you})
+    }
+}
+
+impl Game {
+    fn outcome (&self) -> i32 {
+        self.you.cmp(&self.opponent)
+    }
+
+    fn score(self) -> i32 {
+        let outcome = self.outcome();
+        (self.you as i32) + outcome
+    }
+}
+
+fn main() -> std::io::Result<()>{
+    //read in file
+    let file = File::open("input")?;
+    let reader = BufReader::new(file);
+
+    let score: i32 = reader
+        .lines()
+        .map(|line| line.unwrap().parse::<Game>().unwrap().score())
+        .sum();
+    println!("Puzzle 1: {score}");
+    Ok(())
+}

day3/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "day3"
+version = "0.1.0"

day3/Cargo.toml

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

day3/input

@@ -0,0 +1,300 @@
+dWlhclDHdFvDCCDfFq
+mGdZBZBwRGjZMFgvTvgtvv
+jwwJrzdzGdSbGGnNlzWczHzPHPhn
+cczcbMBszhzzDBTBPPPGjtvtlt
+LqJLfpwdLnvQLRGQjGtj
+gSgnSJJCGSGpGSrwgfhchmmmHzcrHDmbrmMm
+bVjstCsSstCLCrbSLnMpdMndcLddcqcpHR
+wPZJQJwtBfJZmgBwPTcpTdcnfHMppcGMdG
+gmFJzwPJJtszvNhCNC
+DmjZDMZWDqGRqqRpHmmRLTTNTPTfCQJQQLJHTClc
+FtzfvrfFwVgtzztgBLJNcNlTcTVNNQLN
+vgsdbzzrwtqWfWRpZDdZ
+rJhqRhLHhdcQqdHqfQGfPGstgGPlWttM
+DzCpDDmnNCmBZBZnVBmZzBGPfsbglfNPwgPGPMWsWWft
+BZFnlmpBpBzDzVZmhFHFrrrchhRqTdrc
+DWCCWFNqdGFdPVcb
+HllttQsTRlJlsblrHlhdmPLVcVcTccndLvPLmL
+HSlstHgJltghhRrzNBNDzSwMjNZwNb
+dzGSHCWSsGVVSdHVHHWWVVDCgJDpQqLTTRJpgmTLRmJTTpTR
+BvNjMPZMBtBBMvvNMNttlhLQqCJpLmhTRQqQJgRJLQQg
+llNncBlMCwwMnwPZrGsVHzcfFGdHGFGs
+JfZhphMMQmFzDTDjSdrQjQ
+sqHCbCwBVtbqbCqtrWdjzlSJTlrTSWBn
+bHcwbGCGRssNscwtHNbwvmRFvpFFJFvLZMmPLFfv
+qBCrzznVmDCmMMDNgrgcrvHHcgbQcW
+TTTsdJRTRhhlsgbvbdCFdbWvbQ
+JhGGlfRlJsnCMDMqjmfV
+rqLLvDLtStDLQhQDQrQhhNdsmWdmmjjnssPnTMnTzfTsWT
+ZRFFpgCgppcBcnjTsjTMTfPFMP
+GCZpGlwJwBgGHcJhSSHLDDrNqrMtNq
+FsPFqsDNZFNnZrcBmWfWWQ
+lSnRlRTvgrWtctTmft
+SMbGbbvnGlnSDwGqLwNCqNVD
+dPQDcBwJJDgDTPgGgQTBVjSsmLhLTrLmjSLpjSLh
+MvvZRHtMtbCNvCNCNtNvbRfBSMSrjmLpjnjmVhrVSLsnnmSh
+qHZtbBZfRztbHbCzNRHPQgJPJgGgglFPPFqdQD
+MsBsVDspRPfPlhMl
+zWnCFzHbSCwqNmPSjmGlsmfN
+FnHnFbFzsHHCCgzCzbBptVppgvvVgVrpBrJt
+pTLntptZjQLfVDjQTDlVJCSWNCPSCCsSNmFlNslm
+BBHbqGHHqgwSWSCCWwZWWZ
+qRzbhhbzzrHdRRHhRHvzZjfrVTrppVQttDfcQTfp
+DHsdHPHHsHMsRmhMZZQBtljgZGtC
+NFnCbFznLVJbVrjhQthjGBLZBjGL
+wNrfFJJbCpNnfbdwDSDHsvsHmsmH
+jLZRjnMMjJhJnvtQbdHfHZbvHQ
+mBzwptCWlcFCwsHSTpQfQHQfrpTb
+mNltzmsCNmFzGwCBllGRgRgqjgLMnGqjnPjV
+ZqqcqmVVtbcBMFfFMcQfgphJ
+HLWLDvWjjLwTWzzvGLThQQshQllgJDJgfbffJQ
+vHzLvrwwzGzTRGzzLLRPRwRdSVdnBBdSbBSVStbNmnrmZS
+TWVVvPSgwWSqcRgRwbRRcqshsfFzzzChTGNHzHhhhCsG
+njZrjMLlpmDmGfSGtrNttzCF
+ZQBmZdDBZRRPRSBgcb
+TpntvdpnZDptnbnTDGtSFSlFmzCzzmSFRjqlZj
+MWrNcWRMlgqzMjzq
+NPwsPNrBNcVHNNcJHBNBcJwwttDvGVnDptVRtbnTtGvVGtGG
+tsbbvvSfnqvzQLLBjfMLdd
+gJRmRNmJNchgmmrFJhFgWJQMwBnjwrMBVQwQTBdLdVQj
+GcGpGGRGJgqstvpbnCqb
+rsHcrbZHBTTtLtNSwwHLLJ
+mFqhWVsjsVCjQlNJGMwMlMMGMh
+QggzffQRCfgVFWzzCQffqfZpZDcRvTTBTvvZnsdnddcn
+bPFMFFBpMlFfMZMpHGNSrNctJcPSSchJchPt
+zCgwnmgzQDnQgdWWQRgqSrqLSqSgssLNJhgJ
+rQCQQTrRRmDBFfbHBFHZbT
+fzfPQsGrrMMjtHtBHs
+SwNNDqwhWpVTwbDGGDmwSVhZRZHdbCtgBjCRjMtbBHtRMd
+vVTGvVGNvPPvQvfncJ
+cwzMJbclHDPqfJQPfq
+rrqjjTBrqqBjRCgTjrRjNrsGPDhDFGCfWGfPFfFPGWfD
+BZTTSTZgjbSwVptvpq
+PPPPJpvpJsJwPHHPsJdTNZRZZZjTFFmRRRNjZd
+qbWVfChDCDnVVDGfnSFNNjRLmNfBNLQjLjmBRm
+DhFDhbnWCDhGcbJPPwrsrMwrvlvc
+lFSDTwHTSwlTNwFFlwNcFFpjLZvZqvnqLPnnWbgngbbncqbZ
+rzQfMzRGrRGJCffBMGdGsJZWWnqWVqdPPgNvvVZWPWWn
+RJrttBtNQCsNzTpShhHFDwFlth
+QNzQFjNFrQPNbmPpqTTDGswWmB
+ggHRcSlcCVCSzMVqDGwgqTWpsmqwqG
+cltzCZtLClHRRtMZZLQjfNvtrJfhvrddvNNd
+mcfWHffBFnQRQlTFdv
+wssSLVbbzDVbzbggzSzNshNMnvnljRdvQRlMBjvQdnCj
+bhDzVSSJDDJhDLBwtbDzzbbWppfpcmWGmprqqGtqprcHPp
+rpVFrZpgHWSZrFPqhzwcqPwmcVBD
+vMTnQJjQLCbljvvQzTMbTjPNdBLwwDhmhNNqPwmmhhBh
+jvGjjQJnrspGHgFz
+sjssjtZlcphZHwWvcrHTwWJH
+qDdzzrFNNNDGdFDzzVBVVvfWJPfgPmgWPgvwVH
+nqMQGDrnLGnqqLNqjtCZZjsMhZhCMbtl
+JJJsLFmzsrFlSpzPscjgHhnRnmvcjqRvvj
+fCMQbCbTjjqTGhjc
+bfdbWdCddfBbtCfbfbqVWQQpPlBrJLJJSSLwppFssFzLzp
+pdbbzlffWtJbgQwhcphQcCCg
+vHvLFvVLvSfFRLnRFRNHjPjggcssQcjjsnwhsPCC
+vGVGGFFVHLTvDRHDmBbTzfZWMdJZlfMm
+wjCbjQgjTQhNNzgWQCWrDFMZmZDZDCrrMDpLpL
+czGSPznnRGGJGGlVVRVBGGlBmDDcMDFDDZLqfffZFrrZqFpZ
+JPGlvBSJHVGnVsjvQjjzwdwjzd
+MFlWQHDTpnpsFNNQllWFWlhzjGgrgDzGGhGGjvmZDZrh
+PtTPcTLbBCVPTRVcvhjmmhVhSZGGgvZg
+JLPfCwPbTbBPJCfblplMpqWsMpMwWHQn
+QbHVBBzWtzHBNtBwQSgqhqSbFgRLjhmqqj
+ZnCnMcdsDnJTncggFJwRmSwgRFmL
+sTMZpGDvsZcMpcvTCPHwzrfzrpzHpWBrWz
+PMdJWwJWHFWJnNzbDlfbCfMvbl
+rZgttrFptFFcBtccbbCDvgfbGCGGgGDz
+QsZBmsrFscrVrjQJjJQRJWWLwq
+GwNNJwwRThwrWfhh
+SmQqmzsjHssQzCbvsmSSzsQTjWpFTTfFfThchhFTBBfppB
+mmbHbmtmCzzQZzQRdZJhNMdMlRMglh
+rrsPbncQvvgnnrTdGDVcCdpZHHZp
+RwwwhjLLqtJFwjzwtwmwwGpDZVdGDVdZBZDFHdHZCp
+zhzwLhhfffLtjNChgWbbrbnMvPrMrrfv
+tQMtQtTSBFtSmQSttMggMtbtnTnPrZvrnzNNTGZvrZZdLdnL
+HqhwDpDcwlHqpVrrFzvFGpZrrzrP
+RwlhhjwRCjVfjDbMtFWBWJMgWjWm
+WpWVlWzsGlBJpspNclNlhhhmgzrdtzQMQttzMmtt
+RfnPRLTPDHRdPbwvvntnSrFgmvnmtm
+CwqRDCCwqCwbCTqJcJBNcZqdVcBlpJ
+tpfnNBsGGNRppRCgfgRRCRQJGMPPWdwMJdWFFwjVzGPJ
+chLSchLTbLqvqcZLlvvLqbmldMzFFWdzVSFWFMzQVJwjQjdM
+rLqqcjDrcvhRsDfHDtNNnN
+DjZjvTTDqrtTZZSMcdRdmRJrcJNc
+HWgPGVhFPgnSVtnJcdMs
+FPLfBwCWGPfCwfLHCCDBZlbDpBjvqTtDzzDj
+FJNqNFgNFssqGGqBsTlMVcgVrCwLwlhcrw
+fRZzDmDZvvDdZbtdpDZmbrThrLMCvcChwwlSTrvMSr
+zmfZmtZmpDmbfWRDDZdqFljqnNQjGWnsjFqGsG
+rMdMWddmJmvdSdmWfWMddpVRqRFVHRRqMRRPQMRqRq
+tDGtGGhLjLLZNLjjNgNthGtqHTVqRVVpPDRpHHVRQVRPPR
+ZlLtzNjgsZZlssLgtjNpfWfJvlJrrvCJfBmBfn
+hqpWvFJsJFNHhqMWNhWvWRmmDcDMLcwZnjcwnjRnjn
+LdrlgCCrSSTrTnwRjmwRQZwdwG
+PVlfClrLlLlfggtBPzHHhHFbWzJNbvqJFNqF
+TbbQtnDtbGGjGlGsGHpJJmFWFJJrBWWFlWrS
+CZzzNzzhddNchhMhhRVjpCBwBrCvJvpmSCvrwJ
+fhZZhddRjRgZzMZRzPjPTsLGQtHLTHTbDPQTtqPT
+nHnWsQNQQWTWQshwjBJJJmHwFBwm
+VZZpfbffZVvbSbGfBhSwmtmmJlmjJFJJ
+bpphpMfMvMzDbMGZgQNrrngzdTsNqWdd
+VPNddVTPPmdnVcPVZcdTmcDbQTFjMpjtFzbMtFjzsFTssT
+lJCllWCrgvRlgwlJfRRvSzjSjQpbzMHpbwMQpszM
+fRhGBBJJCgrNLsNPNVVhNq
+pLrVDgbNbjVplpsltHBqWSqhSQcHDttH
+MCdCwCGTmnTmmmvTTCwCqNhHQhRWcwHWBRHSqSQH
+TNTFFPfffTvFTJvTPCPTFfGdzVjspVLZglJbsbZpVblrzjlb
+cdPzFrldgcdCrnlznPzrBNRssLLBbVNVZsLHRHdm
+wTQQwvvtqwqcGvTZmVHBbVLLBbRV
+GWJSGfJWcjQwhQQWjqJhhGfgpMnMzDnpMlPpMnDlMrzl
+pMhqTTsSpdBPpNBshsdMMTQFvFlQtQWCRQlCllVFqVqG
+dfcbnmrnjzRFvGQQGvfv
+mDrjLLLcJjLhpZSSJMdpph
+NGZNwqFqZhhcFSCfRzwdzRfCzVRw
+QTTmBTsWQWJPPCvzvpHPzdvVFR
+bsmWTBbQDbmbLQQMsWWQchgqLqhGGGGZLhSFjhqS
+HgmGlgsvBBDgBGCdHHvHwCGwhZJWhTjSdhTSFFFhJtSJTJhT
+RQfVrfQNszMQfpMzpNnfLbtjhtSbWJWFWtFFtFJtFSZq
+PNzLfnLnBCPHgsgC
+mTZGgCdNSNmCQLLpPnDhRlGhpV
+vWJHWFsfHMWBBFbBsjfjHrFfLRRLPPnpLthttRVPLSnhSPbS
+fzMrBjWfBrzsZCZmSTgQzcNN
+mgmCZCMgmnZmZgBZpgpJfbQfwSQPDTdfdwSDfwhn
+sHhcrWLcFlzHcHRNNFvNFcFPwDDTWdddDdqWbSTWDPTTQS
+RNsslsRrNcRNvNRFFNvVsghZBJtVCCtCtGghjhGBGG
+gchrcRRdnRwPPnvQ
+CVCCSrDjFHjVDbBLFGGBSvwnwNMnMsPPNsNPvwPQVM
+lHLCTHGDCbbjFTTzdWlpcqfgcrdzZg
+fRDPsDsqqJttttJSzPDgJWQCbQQbGMWCCnGGPVGVQQ
+rTTBvZhrvBnWWDWCbZWW
+cwLlTLpjTwBFLLhgfRRfmRqRDmRdjq
+sprGGPTrJTsGPzszqGzNtTtpfbQddQSQSDFDFvvbZvwFbbfN
+LWWCMVmwMmgWFQfFDDvZDgdF
+mlMmRVCWVMmmHRjVCmjHWRhMzpTtlrlPzrtzwlsGPrpwtrJp
+tsfwwfjfdfrtrClfvwvvLnTHNmvLHcNccRNcvNWH
+qQSqZqFQRBzghDFncHgmccHNmWcNmM
+SQJphFJzRDSsdpVlllrCrw
+vGQqLQFvBvLvdNnvjnvNDc
+TRJwmWmZWlCCmzznbNhhbDhRgj
+CCTtDTlmDTWTmDmZZlVLLsFfstfFFLsBLQfF
+cfWflMmWWlWfPWBhBlQtLmmvrrrvCLjvRTjLLwwr
+gSgbsbgHdsjzHbqbdVDLZLvTZwLTvSrZrFvZLw
+sdbJqDNdjJNdsJBpBWpJlMcfcB
+FHlMHPqDLlPctgHSnttCSC
+zhrmBrTwJTjBmQcSQvQqbtwGvg
+jBjmBmJjjjRZTBzhhrBJLDdZqfpDMdfWWlDDLMlV
+zPVdbsBzZdwqJGhrLTvNNJqH
+tmmCgCPCDDnptHDjNvGvhrDvLv
+pRWRlpSpPllClnpbQVQwFFVSQFVBZz
+nDrCvmvMnMSmsCvblBzzCZplbJlTbZ
+FNRtFWRfcGqFGQbzlZTQqQTBbd
+GRwFfNtwFRNFGMvBsnnwMMMBjn
+LVTBjjlJCDrnJzJNQR
+GsGGsggGpfhgpchgdqzbMzzhzQRnnMRrNzzR
+PwWFqFGpwWpdWgfsGggdmjCVHPHlCCCVZNCjVmVj
+qVTsCWwbCsPlCVfcbvfPDgLzbzDDhrzRrjgZghgr
+ntmHmNpSQNGtntNttmSdSdBdjrrDLQZQLLhRrFFFRDTFZhDF
+mtMtBNTSNBpNJStMGSdHppNcVWPsWvqVcsVJfwwqlqWqlc
+vvWzLvvdpZDvhTpcrLcTTLpdwSPnCfJwCMnQSMwSnCGJrnwr
+ttHVmVNNsHBBRsHbMMwwnjnjBfjJwCMP
+tsVllgNVqbRlfplldDvDWT
+mLjLsQqLQqsBRvvlRBLRlT
+bhgtDDhCtmptmTTS
+nfmdbggwGWrfsPzfWq
+JpWDcSGJpGzsHPSSlbbd
+wVRqVZwwRwPDwbDddH
+VtVVVLthLVtVgfQLRTNtqDcCcJBmmWMWWprpFrcBJWNp
+dhhhDtmLdttdPlslGlRFjfzBBpzzRpGJ
+QMrVMwbVrrbvVVCrvcnqQQrrSMBJfpjFSzfjJFMFRWSpjjFG
+cwvbHHbCqVchRDHgDsPTdt
+CgVNCtDsDtJGZZGqMMGhDq
+cLRnSHgWcRdLHWSSRLjQdlHBTTPcPwwhzqzTMBPTwhPPwP
+HnnnglnWWgdRjlmQNsNFmJCFJFvsJsNN
+hfccLbjhfSRbfDZjFRJzrlvlwwlnnFrWwzqr
+TCsPLNtQdpdQQVtVNvJNJWlzJzwlrvJl
+pHtPsPtPtCQfbRHHDHhMLh
+nWRWgLtWnfTcZNNsscfd
+JMGzMVJwMVTvzVQFGHMMmPdddsPsCjldlHPcScNPsP
+vGrMQQmmvTQzMJpghWRWgpbbBqLbLR
+WSbhFbPTpRfTfPdhpfbhSbfPQLzlQlzlHvtQsvlltlsgHdgQ
+pZcGJDZNGcVrJwrDrrnvtNvlNzsgtgzvvsgt
+qmJZZJcBqwrMJcVbWfSPPWpmpjmSCF
+jHVjjCcpNrDgjsfB
+ndqllRvJQtqlQQTRWllFNDrsMZBfDBLvNMNDfsbZ
+qTFnWJqdWRdqWRlnTRnQGnTmwwSHCzpcGNmHNcPVcHGmCz
+pZCpBhDfvgBVZQGMMVZVlq
+sLsLTTSssjPnTNbFGRGFPVHqMMRF
+TsNSccnjLdcsLjdmjWvWvBhfmvWpCGhGhD
+VWFFFPMpPVSMbTppHTnHTbRH
+DtvfNdBNddDNSLjsvDTTHnzzHwrTrwsrwqbT
+dgBLNffdgjjtfBQSvgNjNDlvMcQJmJJmZCMmVVVZFPFcPMGG
+VWsQLHMVVSNRShWLhNSNLjbbbddbpDZDddcbZdDRztpd
+FPlhhgPvThGFJndnnCCnJzzdCp
+qrTfmllGvfvGqwNMMMsffsQsNh
+NsmFqNlmnQRbCFsmJgSffpPcbvSfrVvpgS
+LhZGDZhhwtDHMwDdHGhDjDpTzzPdzgTvcPvpSSpPrdrv
+jgHMjBLhwtZMHMHmJNNJNFlBqlBJNn
+bznSQggscgMcSTTfJbSQzQFwClMhmCmthClvMwFLwhZL
+BRWBPBVVPjPNVHpVqlqrvtwFqmmLqltZmL
+WDVddNHNvRgccgsDsgbT
+sNgnQLtLLLPPnsPpqdqjBclpGWjcWjBG
+rVCChSZhVrrwqVDVHSHmMjldGfJGfHddJGJlfGjGJj
+CVZmDvZCmmhFVVrCgTNbbnQFgbsqNqNQ
+WmMmSSfJNRRPfJRMRMtllCgdStgbgttgCdDd
+QGBrvzwBczlgqCtDbvDq
+QQpBGFrLQjQzGVVRNjPmNNWMbW
+gGljnJhnJtllpNVCHWcccdTdjdmB
+bLfSQDSMSHmBnwCB
+LFMDrbFfFQZQRzLZnbgtlsRGtltpgNhgPpPG
+cRThZZchCThtgTRhZTRtjWFjWNwqCjGmwFjqqffC
+DPDPGzPMHDbrpqjfwrjqmjmp
+JVHHDdVdVbvGMdnVdQVdDbHcRZllhRtgStRLThRSTcBTvc
+lQWPSBrrPZGgPglGssDfHnWsfDFHHvHh
+TDCqpttptJNLtwNpbwTqzqHshsvsMMFnmHMNfssmvmvf
+JCjqVpDtrBjQjrlj
+wFGWGpFLvCczNSWWsz
+tlfgtftjlbtHHlDBsBzmQQnsQDQsCn
+gjfrsVqVgPlfqhvLdvdwZhGq
+pHpZHBSvRvRCBBZCTMngRnWndnRmWcgg
+jsfrfrjJFDwDDMMggMCGWGcfmG
+qbCszCjtCjQsQrtZVBHBHvBvqLZvlp
+scFzsPScNgNPNgQzpttlCBCwpLrMLCrDdljLwq
+TjfGZZjVwMZwMLwr
+vnGbWTvTmFRjQFQPsb
+bVLrzqrzJVgJbbtVrWJVgppcBCzBvdzwBCCBHDcBvc
+hflPQnMQmQSRlQMPNRTHwwHHHqpHpdfwdBCp
+hFhZMhqSNMNbrZgWWGWJjZ
+NJsgNjJlMHQrwnRgSRPwrP
+tqpQtTFpFvbGpzTTWSrnSbrhwChCnRfrCf
+GtcvGqQpttzcqdFzWppDsZMJjBBsBJcBNmBjMsLJ
+lGfZGZhFfhdSWqmFFWSS
+wDRDPLcDnjtWbSmqrSCSLC
+MPwmtVnVMjztznHPgQhQfJfvvHHGggQZ
+llTspLllCHmLHHndldqHdlLQQPSBQczZSFDDQZSNGcGG
+jMhwvVrRjbRhFBZNGPcGNN
+wVtrrtRwrfrwftjVjwWvMrRpsqsnsHsBglslCmTsdWdHTd
+vPvmTGgDPRvGpDPGPqGHQnWJQJMBBzJBlBQWlHWl
+bfbwNsmwFdLjbfrrLsSfLNQtMllznBzJQZMQtMlZZnnF
+frssSscssNfScCjfSCwjsDmRDpGmDRDvvvVcvRDvRp
+LtlPZPjBTbWsWJVJVzdT
+nnprqhrqmzfrSrphqfCChVVGVDJWgSHHWgWsRDVHWd
+nrmppNqhcCrfMchcMCncqbzPZvlvlwbBNjPjtNjZjL
+FPWsFdSspVbbbtWVvl
+CCHnnfHHvCwtVMhzlzDllC
+LrGnjGfgfvcwfgrLrBjrBLgwdBTSRBFsRZdRsSqFFSFSSPPp
+whGCLqsrjgGhhGFqrCCFGCGzTRTZJcNnzlLTnznNHcnzTH
+ddvVmbfvdvVbDVQdvvdSzpNcnJzlzSRHNJpnJcSc
+BPdvfQdWtPDDPfDvDQVVPmbhssCGGMqgFCFMqGMWgMjrRw
+PSLbGmWPSPLQbMTPWGFWltthdDdrmBDHhdDdczzDRh
+VfCngVfgsZwCftrZdhcZrdNDzz
+CjVJJJqnJwQhWPPLQlGj
+ntnnQmTQTQGVWGNGNNlClG
+jDffjMSvqjHzHHzwNVwNVcCddPVNdD
+ZszJsrrZMjsHqqvZJLRQCbTRQbJmThbt
+BgLHgFDsJNWgQgflWd
+mnVVcCHnCGRcVnZSjmlthftMQddlfhQctNfW
+qbSGqmHSTFprvpvTTL
+dvdTMvvpdLpTcSLvdLLMmhfFBftwCNhRwRNjtCTRCf
+lshQWgsgrHHqlFfRqFjRFfFwCB
+rsgHQbJbrsGHHlgQHgJrlHrPZdhdpMZGDSDpdPLcZhdvhZ

day3/src/main.rs

@@ -0,0 +1,62 @@
+use std::fs::File;
+use std::io::{prelude::*, BufReader};
+
+fn main() -> std::io::Result<()> {
+    //Read in file
+    let file = File::open("input")?;
+    let reader = BufReader::new(file);
+
+    /*
+    let value = reader
+        .lines()
+        .map(|line| {
+            let line = line.unwrap();
+            let (comp1, comp2) = line.split_at(line.len() / 2);
+            let duplicate = comp2.chars().find(|c| comp1.contains(*c)).unwrap();
+            match duplicate {
+                n @'a'..='z' => (n as i32) - ('a' as i32) + 1_i32,
+                n @ 'A'..='Z' => (n as i32) - ('A' as i32) + 27_i32,
+                _ => 0,
+            }
+        })
+        .sum::<i32>();
+    println!("Part 1: {value}");
+*/
+    //part 2
+    // fold the lines into groups of three
+    let value = reader.lines()
+        .fold(Vec::new(), |mut acc: Vec<Vec<String>>, line| {
+            if acc.is_empty() || acc.last().unwrap().len() == 3 {
+                acc.push(Vec::new())
+            }
+            acc.last_mut().unwrap().push(line.unwrap());
+            acc
+        })
+        .iter()
+        .map(|group| {
+            let (g1, g2, g3) = match group.as_slice() {
+                [g1, g2, g3] => (g1, g2, g3),
+                _ => panic!("not get here"),
+            };
+            match g1.chars() 
+                .fold(Vec::new(), |mut combo: Vec<char>, ch| {
+                    if g2.contains(ch) {
+                        combo.push(ch)
+                    }
+                    combo
+                })
+                .iter()
+                .find(|c| {
+                    g3.contains(**c)
+                }).unwrap(){
+                n @ 'a'..='z' => (*n as i32) - ('a' as i32) + 1_i32,
+                n @ 'A'..='Z' => (*n as i32) - ('A' as i32) + 27_i32,
+                _ => 0,
+            }
+        }).sum::<i32>();
+    println!("Part 2: {value}");
+    // find common letter in the groups
+    //   find common letters in the first 2 then find the common in the third
+    // sum the common letters
+    Ok(())
+}