From de32e56fb62a130406dc11a27f54d87f3d491d26 Mon Sep 17 00:00:00 2001 From: Patrick Stevens Date: Sat, 3 Dec 2022 08:43:24 +0000 Subject: [PATCH] Day 3 (#3) --- .../AdventOfCode2022.Test.fsproj | 2 + AdventOfCode2022.Test/Day3.fs | 59 ++++ AdventOfCode2022.Test/Inputs/Day3.txt | 300 ++++++++++++++++++ AdventOfCode2022/AdventOfCode2022.fsproj | 2 + AdventOfCode2022/Day3.fs | 36 +++ AdventOfCode2022/Day3Efficient.fs | 89 ++++++ 6 files changed, 488 insertions(+) create mode 100644 AdventOfCode2022.Test/Day3.fs create mode 100644 AdventOfCode2022.Test/Inputs/Day3.txt create mode 100644 AdventOfCode2022/Day3.fs create mode 100644 AdventOfCode2022/Day3Efficient.fs diff --git a/AdventOfCode2022.Test/AdventOfCode2022.Test.fsproj b/AdventOfCode2022.Test/AdventOfCode2022.Test.fsproj index 22fd626..e7c8bdd 100644 --- a/AdventOfCode2022.Test/AdventOfCode2022.Test.fsproj +++ b/AdventOfCode2022.Test/AdventOfCode2022.Test.fsproj @@ -9,8 +9,10 @@ + + diff --git a/AdventOfCode2022.Test/Day3.fs b/AdventOfCode2022.Test/Day3.fs new file mode 100644 index 0000000..ec9fee8 --- /dev/null +++ b/AdventOfCode2022.Test/Day3.fs @@ -0,0 +1,59 @@ +namespace AdventOfCode2022.Test + +open System +open NUnit.Framework +open FsUnitTyped +open AdventOfCode2022 + +[] +[] +type TestDay3 (efficient : bool) = + + let part1 (s : string seq) = + if efficient then Day3Efficient.part1 s else Day3.part1 s + + let part2 (s : string seq) = + if efficient then Day3Efficient.part2 s else Day3.part2 s + + [] + member _.``Part 1, given`` () = + """vJrwpWtwJgWrhcsFMMfFFhFp +jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL +PmmdzqPrVvPwwTWBwg +wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn +ttgJtRGJQctTZtZT +CrZsJsPPZsGzwwsLwLmpwMDw""" + |> fun s -> s.Split System.Environment.NewLine + |> part1 + |> shouldEqual 157 + + [] + member _.``Part 1`` () = + let input = Assembly.readResource "Day3.txt" + + input.Split '\n' + |> Seq.filter (not << String.IsNullOrWhiteSpace) + |> part1 + |> shouldEqual 8018 + + + [] + member _.``Part 2, given`` () = + """vJrwpWtwJgWrhcsFMMfFFhFp +jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL +PmmdzqPrVvPwwTWBwg +wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn +ttgJtRGJQctTZtZT +CrZsJsPPZsGzwwsLwLmpwMDw""" + |> fun s -> s.Split System.Environment.NewLine + |> part2 + |> shouldEqual 70 + + [] + member _.``Part 2`` () = + let input = Assembly.readResource "Day3.txt" + + input.Split '\n' + |> Seq.filter (not << String.IsNullOrWhiteSpace) + |> part2 + |> shouldEqual 2518 diff --git a/AdventOfCode2022.Test/Inputs/Day3.txt b/AdventOfCode2022.Test/Inputs/Day3.txt new file mode 100644 index 0000000..fa51773 --- /dev/null +++ b/AdventOfCode2022.Test/Inputs/Day3.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 diff --git a/AdventOfCode2022/AdventOfCode2022.fsproj b/AdventOfCode2022/AdventOfCode2022.fsproj index 7d9abe2..354b2d8 100644 --- a/AdventOfCode2022/AdventOfCode2022.fsproj +++ b/AdventOfCode2022/AdventOfCode2022.fsproj @@ -8,6 +8,8 @@ + + diff --git a/AdventOfCode2022/Day3.fs b/AdventOfCode2022/Day3.fs new file mode 100644 index 0000000..1b08f16 --- /dev/null +++ b/AdventOfCode2022/Day3.fs @@ -0,0 +1,36 @@ +namespace AdventOfCode2022 + +[] +type Priority + +[] +module Day3 = + + let toPriority (c : char) : int = + if 'a' <= c && c <= 'z' then int c - int 'a' + 1 + elif 'A' <= c && c <= 'Z' then int c - int 'A' + 27 + else failwithf "oh no: %c" c + |> LanguagePrimitives.Int32WithMeasure + + let part1 (lines : string seq) : int = + lines + |> Seq.map (fun s -> + let s = s.Trim () + let s1 = s.[0 .. s.Length / 2 - 1].ToCharArray () |> Set.ofSeq + let s2 = s.[s.Length / 2 ..].ToCharArray () |> Set.ofSeq + Set.intersect s1 s2 |> Seq.exactlyOne |> toPriority + ) + |> Seq.sum + + let part2 (lines : string seq) : int = + lines + |> Seq.chunkBySize 3 + |> Seq.map (fun strArr -> + + strArr + |> Array.map (fun s -> s.Trim().ToCharArray () |> Set.ofSeq) + |> Set.intersectMany + |> Seq.exactlyOne + |> toPriority + ) + |> Seq.sum diff --git a/AdventOfCode2022/Day3Efficient.fs b/AdventOfCode2022/Day3Efficient.fs new file mode 100644 index 0000000..8d127e9 --- /dev/null +++ b/AdventOfCode2022/Day3Efficient.fs @@ -0,0 +1,89 @@ +namespace AdventOfCode2022 + +open System + +type private CharSet = + { + Counts : int array + } + +[] +module private CharSet = + + let empty () = + { + Counts = Array.zeroCreate 52 + } + + /// Not thread-safe. + /// Returns true if the element was already in the set. + let add<'v> (charMap : CharSet) (key : char) : bool = + let key : int = Day3.toPriority key |> int> + let previous = charMap.Counts.[key - 1] + + if previous = 0 then + charMap.Counts.[key - 1] <- previous + 1 + false + else + true + + let ofSpan (keys : ReadOnlySpan) : CharSet = + let charSet = empty () + + for key in keys do + charSet.Counts.[(Day3.toPriority key |> int>) - 1] <- 1 + + charSet + + let contains (charSet : CharSet) (key : char) : bool = + charSet.Counts.[int> (Day3.toPriority key) - 1] > 0 + + let intersectMany (sets : CharSet array) : int = + let rec compareEntry (entry : int) (arrCount : int) = + if arrCount >= sets.Length then + true + else if sets.[arrCount].Counts.[entry] > 0 then + compareEntry entry (arrCount + 1) + else + false + + let rec go (i : int) : int<_> = + if i >= 52 then + failwith "failed to find intersection" + else if compareEntry i 0 then + LanguagePrimitives.Int32WithMeasure (i + 1) + else + go (i + 1) + + go 0 + +[] +module Day3Efficient = + + let rec private go (set : CharSet) (s : ReadOnlySpan) (i : int) = + let char = s.[i] + + if CharSet.contains set char then + Day3.toPriority char + else + go set s (i + 1) + + let part1 (lines : string seq) : int = + lines + |> Seq.map (fun s -> + let s = s.AsSpan().Trim () + let set = CharSet.ofSpan (s.Slice (0, s.Length / 2)) + + go set (s.Slice (s.Length / 2)) 0 + ) + |> Seq.sum + + let part2 (lines : string seq) : int = + lines + |> Seq.chunkBySize 3 + |> Seq.map (fun strArr -> + strArr + |> Array.map (fun s -> CharSet.ofSpan (s.AsSpan().Trim ())) + |> CharSet.intersectMany + ) + |> Seq.sum