diff --git a/Cargo.lock b/Cargo.lock index d37200f..5fda623 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5,3 +5,12 @@ version = 3 [[package]] name = "aoc2022" version = "0.1.0" +dependencies = [ + "seahash", +] + +[[package]] +name = "seahash" +version = "4.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b" diff --git a/Cargo.toml b/Cargo.toml index c1cd145..c0347c9 100644 --- a/Cargo.toml +++ b/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] +seahash = { version = "4.1.0", features = [], default-features = false } diff --git a/src/day3.rs b/src/day3.rs new file mode 100644 index 0000000..2b88d74 --- /dev/null +++ b/src/day3.rs @@ -0,0 +1,68 @@ +use crate::util::prelude::*; + +static INPUT: &str = include_str!("inputs/day3.txt"); + +type Item = char; + +pub fn item_prio(item: &Item) -> uint { + if ('a'..='z').contains(&item) { + return (*item as uint - 'a' as uint) + 1; + } + + if ('A'..='Z').contains(&item) { + return (*item as uint - 'A' as uint) + 27; + } + + panic!() +} + +pub fn part1() { + let sum = INPUT + .split('\n') + .filter(|s| !s.is_empty()) + .map(|line| { + let len = line.len(); + + let (fst_ruck_str, snd_ruck_str) = line.split_at(len / 2); + + let fst_ruck = fst_ruck_str.chars().collect::>(); + let snd_ruck = snd_ruck_str.chars().collect::>(); + + let both = fst_ruck.intersection(&snd_ruck).collect::>(); + assert!(both.len() == 1); + + let both = both.iter().next().unwrap(); + + item_prio(*both) + }) + .sum::(); + + println!("{}", sum); +} + +pub fn part2() { + let lines: Vec<_> = INPUT.split('\n').filter(|s| !s.is_empty()).collect(); + let elf_groups = lines.chunks_exact(3); + let sum: uint = elf_groups + .flat_map(|lines| { + let item_counts = lines + .iter() + .map(|line| line.chars().collect::>()) + .fold(HashMap::default(), |mut map, set| { + for v in set.iter() { + let ct = map.entry(*v).or_insert(0); + *ct += 1; + } + + map + }); + + item_counts + .iter() + .max_by(|a, b| a.1.cmp(b.1)) + .map(|v| item_prio(v.0)) + }) + .sum(); + + println!("{}", sum); +} diff --git a/src/inputs/day3.txt b/src/inputs/day3.txt new file mode 100644 index 0000000..a29ec79 --- /dev/null +++ b/src/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/src/util.rs b/src/util.rs new file mode 100644 index 0000000..022cd45 --- /dev/null +++ b/src/util.rs @@ -0,0 +1,19 @@ +pub type uint = u64; +pub type sint = i64; + +#[derive(Default)] +pub struct BuildSeaHash; +impl core::hash::BuildHasher for BuildSeaHash { + type Hasher = seahash::SeaHasher; + + fn build_hasher(&self) -> Self::Hasher { + seahash::SeaHasher::new() + } +} + +pub type HashMap = std::collections::HashMap; +pub type HashSet = std::collections::HashSet; + +pub mod prelude { + pub use super::{sint, uint, HashMap, HashSet}; +}