format d3

2022/d3/data/example.txt

@@ -0,0 +1,6 @@
+vJrwpWtwJgWrhcsFMMfFFhFp
+jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL
+PmmdzqPrVvPwwTWBwg
+wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn
+ttgJtRGJQctTZtZT
+CrZsJsPPZsGzwwsLwLmpwMDw

2022/d3/data/submission.txt

@@ -1,6 +1,301 @@
-vJrwpWtwJgWrhcsFMMfFFhFp
+wcsbsWwspmFTGVV
-jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL
+RHtMDHdSMnDBGMSDvnvDjtmpTpjTFggpmjmTFggTjmpP
-PmmdzqPrVvPwwTWBwg
+vtCSGRMBDzHddvBHBzRhrlcZhlLzWNlqblhzcr
-wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn
+shhszHNHHZWqSzVNdClMjlFjBBbNTB
-ttgJtRGJQctTZtZT
+tQQGmnrMnJnGfmvrRRPCjlbljFBdjFCjTjnP
-CrZsJsPPZsGzwwsLwLmpwMDw
+mRwtfGrMmJtwRDvQJQrJpMLSzVDHzhzHZqZzqSzcWVWH
+WsWWgrtgsrhTQtsFcWPcRMCCTvqvMvqNNqMMHlMq
+bBJrBGbzzLJznJrbSDGGJLqmlvqMqvlmLHRqRZZRNZ
+bzJfDGVSzVrJGwjVGPPpQthdPsPpjdphsc
+pJpCCBSWlczWWBWMHdMmMsFmpddrgF
+wfVqZZGVQvzsMqmMgHjm
+vDZGvPttQTVtGDQDDDGwbSCcSJSCJWTcRRSRczRJ
+HLVHsVWLwbWswbpWFWrrmThfTPNnhNSDDNhDfznTnhnS
+pBRcvGvvBtpGcqqQvgcphPfzfDGhzdzPDzDDhnhS
+ZQRvqBptjJgZCtJqqMMMLHWwMWZWHHFFHm
+PvPFPvLLLSvNFvQNWNPvrPLrZjwhMttTwtTtQZBwqjqtZqwM
+HJDDbHjgppzCDCmzpgzsGbCsTMZqZllqhJBhMTtVBBhMtMth
+zgGncmGGzHCnHDpDgDCGsmFLLPFjPRRWLRjdcjrcdRLd
+zHnWzntnBRWTSBzRBddpFvZVcHpLFvjvLppvHP
+MmmWmNGQhbCpZVLLbccvpj
+QDMCGrNWfwNznBJsJzDBdg
+tcRcZccZmdZJctRcjrlhNNDfrdNdSfNsNT
+QHQpBVvMpRMwgBgvnHRFlhrSsgNFThgTFFflNS
+vvHpVBBBGBppHvpLvHGbjmmtCqWLJJZRzZZZZb
+ZBtTDZRWsTsDZVWVZDmjpbLbpSSzmLpWrbrS
+MFNNFvvwFHwlhmNrCStLNtjzrb
+vwffwcHwflGqGflHJfDBBZtQVBgZQJtBBsnT
+pTJcmMJTspmpMZZJJZHCQQMzPBlQdWWWFzWP
+LDnwrdnDnqjfqgvfDjrfFlBBPFHFSHPQCBvQSSWB
+nLbjgLjdbrwVRcppsscJVRRR
+mHnfggmMtpHPPBCs
+PJjlQQRrJhJNPPTtBsCbCCTlpptd
+rSSDhNQwShRRjhmMPmzMDfPmfLzL
+HzLFBgrCthtFrrhFSCCCvBQNRVmJJJmnpnddmppddVtJ
+MPZsjDWPjZsVzNTzpVdRdZ
+qMfjWfwclsPsjwzqHgLFhwGFwHrFFrSC
+llllmSbhNmSbNzlPmRNCcgLLchHHpTGsCTQGpT
+dVjBrvBBVLJQsLpC
+frZBWBDMFndStFsSwzlPlq
+vmTVVtmJHwCwDllttTsrcPcMrfqPMMpjMq
+LQGBRgGGRNgGgBhgzHfpjPqsMjpLcLjrPLpq
+BdgzgSRGBnNHJtJlVStVmt
+FbDQsFjPVHFZFSbrVjSVvMJlGBJhDcqBBllJGccJnh
+RfTCTTpmppfgwCpwpLwRMnMGMlcPGqhddPcJnl
+zgLPLNCCpLggzmTzTWmVrjVvrNvjjjvbVHQZZH
+RBjjpwmRszBdvhLdSvpVpV
+GrbfbJWmQJGWrGZZQMbSLggfCgSHhCSgShghSC
+DWNDZQcrbWQrZJZGQQZPsztzBsPmBTzwcwRwjT
+rlvgglvZqbrbWbWWdvdmPHBBNMNJGqjGRRnHnPBJ
+cDFDcfcCDhLzsCfLDVpGPRJMPsRJMPNRnjHHGJ
+DCfMVDFVScVMVQlgmZgdmWQQmS
+nWTWWgwNgGDdBZBVcvDzzJccVlCzHD
+RLppMMLpRqfMtMjtMCHJFSpzHSvSpczJdl
+RdLRbQRjsRMrMRRMfbQLqPjbmnQgQWWwZmggnNTgnnWwhBhn
+TmzjMjrmjmjBmHLvGPpbvWGqJzJJ
+CfScwNDssDVCccdNVcNDQfbqJLqSLPpJpJJvJPpGTWJb
+nddCQTfQVVrHmjMnrMFM
+WHDnTwvwcwZmWwQTnBtgbVLLbgfSlTfrfb
+CPPGdJRzNhNpzPJtMgBLbgtlLLfLMz
+GJptpdFRhJwDmFHDjvnD
+PNcWDNnNDcLjDDcSRWtQFfzzzQgPgsssZtPZ
+MGhJRJGGrlpVGVHVCqqGqBQvzFzFfBvZvvtZtvFzvZvQ
+JmJplCrlMNdmjbNbWR
+pqpqFJPPSswJshNghg
+zTHHrrbLzDQHccfhqmDshgCwfmqm
+rtqqtTTHtzGLPWBdnGBSWGSS
+gmNvgVqjjqzfMRgrRtPcft
+WswSQwWWHGCsHQhlGGLLJRbLMRfRGcMb
+dQCRCWhhwCwFwQshhRTmmBmFjFTTVNpqTnTj
+FZvqSWqjjZvvrNSvbblcbslDppDHbcsS
+MmwLTwPmBwmLJJmLlWzWnDllHcHzcDHM
+QRwtQtLTwwQBTPfFfZdFvqqrFGWjrh
+MqlnnNvJJZnNNdJZZLvLJnMzjjCTCChgWjccWqcjhcgcWR
+tbddSHDBbHgHhHTCjh
+mffBfbpsFSdQQDbQsrlJvwJNLLJMrrlsJr
+RjqbNRRbDDqHndbcHDqdRHcChsffCQJJssZGpzpCpJphJd
+VrMmSbrWVMtMtLmQGCfZWJZCfpZfJW
+PgSPgTvSSHjjBbvbvq
+whclNQQfcCFCcrJRjmmHNWsmLs
+PPzMbqBPLVtnTppPTPzHJrGWJRRvsjjjRHssRb
+PtgPVZTtTLMtBzqPqttPVMClcdDcgCCfCQDSdSgCwlhh
+DrcrsvcNtLWSFPSFszbM
+HqTdHJdQhGJBHQHWWDTnnPzbMMzPnS
+hdwfqdhQJfjlccrfvNDLfl
+BBPCWvjvTLrHTHHPCTndfwhbdnnZZfDhJwfJVb
+msmgNMMcgmgczlmmgQNlddpVDDZpZpDfhZfJwsJF
+mmQmMgSgzmqSRllGmgjPHrvvwHttjLrLRWWB
+RwvDvhjhMvwlFNwNwCWCCWWLZcbGGZLGJVrppbZVcjmpmJ
+tfnfsStnPPfTfgnPSSzPflJZZZrlZJVzLLmZJrzVmG
+nPHqgfsHQnffqgSTldHTPnPHWMRFFqqFhNNNCwNCFMMhDMhh
+FmwFHmnlGJfnlSlmrfsSvWgZNWNvLvtqLqDJhWJD
+BVVTTMqRWvRZRbhW
+pMBPCzVPQcQsGqSFmPFwSF
+TcpTpwqZqMpZqlZCpZlwDjjcPNdgdPjHHHdvhHQgvv
+zQFBRbmsQbLLBnGBvFdPghddNgHjNSSj
+QnszWVzLfsLGbnGQbwpVtMrwZTqpCqpppr
+WrZmrJcGwZdGZZmHdJcwGWcZsdFFLqTtLVtSTLtvvLtLLqSs
+fnpCCQClfpQlzbbpQpflBpjhLVSTvFhjqtstVsjtstFVMs
+QBQRnbCRpnPngnbggCzzRClZwJHFHDwZJPJGWHwmNGHPZr
+fDhjvftQtDwgPhdRcRRP
+bbNSgllVNMCWVnbWmcdFdmmFdpFpRrPPPw
+NBzBglNzBvvGZDJQ
+rGbbtStjSdbGtDpjjJbbRRbdrcCsCCrFqhllrFHsFsCvqCWH
+TzgMMgmTVgzzTMLLfMHvTFsFCqHTvFsTvshF
+gLMPBgQmQmNzVZLPzPppjbRhhddGBGSttbpR
+zMJTpMzpVczHbCzVJVFCpJPngnBqVZqsRZZPnjqRgmjR
+wttwNdfLQwLhwhhDDhWvgRmnPqsQqjnBPSZRgjPS
+DdLwGGvNvhlvrrMFlFTcZrpC
+llBQWMScQlSSBjMrvrrPpFHFBDFDFJTmTtFFmF
+nzZzfVgzCNtnJppDHPnPpp
+LdRNfVdzbzCCjcvllMcsbtjj
+pWFwpFhprTnFfWwZrsBDmsqBvZvjjv
+VbcHCthtzQtNqBsvsZvQmQsj
+cltzzVcJSMtRWdhJLhRwdh
+lmmmLRdZnjBlGgVhNSVvRMWN
+bDwCqCGPbwpPwDPPpCpqpPbScvMSMSDWgVcSShNNVfgWWv
+bTpzqJHPFFJqbTHswLlGlBntGnjQtGBZTT
+pVjVlDDhmRPlHlHPWzWVWrVrcWztVdzv
+GCqGGGJSFbnLJLLfrLfPrLdgrrgfWd
+PbJSQGSsGnbMbqSFGBMMbsGTNwpTRwppDRsjwlNpsmHwDl
+GcnPbbbLqDPDBPPDlQ
+JtTChNfRpNJMTCfMTlJVsdVHvDddHBVmQm
+TzlffWNfjTfjjCjfTtRrLgbnbbnSSwbnLzZZzr
+hggWzjLhzhLhjzVWgpCpTFFHtCJFTJTHHHdG
+lvSBvNNSNSSmlbwmMJCGtJQCHmdT
+cfSlSSlvBDBPnlPPDZLsgtggZZVVfhzRgV
+gGVJGvVVZZLvQLWQppccpctpNptMhnhSjjnM
+fzQBsBzmwPzdQrRbSFNFnsSDchjnFhMN
+bCwQRbbCJvlGCHgL
+NMgdHVSqgQcVHmlllLDjlCLdjL
+whTRJtJTnthWBlLLLmlFtVmV
+wRhnGTpzzTRnVbzzWWbJwbhNQrZHfpNgMQpfZQHHNZZHHQ
+qNNlMdbNrlVsQQfswQNCmW
+LJzBvSdLSHpDJzzzHJnHnzFQCCmmswmfwBGhsQfWfCwW
+HzSvHppDDRvgHzzcnqTrTtllZdRrbRVVZZ
+TWVVVFVPpjVFtRfPBmmzMMPCvmLm
+hDDrwndQQbbhZDMSMvcflMLmfnBL
+grdggqsbrhdJJJrhbwbbsZGHVNHtTWpVBFVTTTVTHtNg
+tLbvnTCzCVnzzwVTJVlwltMFvQFQRFFrQPBFdNgrMBNF
+pShsqqmGjZfZccsqSfbdNBMMRQGBPgMdPMPF
+HhspDpjhSjbcSmcqhZDcZZjTttLVwlTJJVWtnWVlWHCltL
+DwQBvwBnBrSVRrZM
+JWWGRssgRsFgzsFPJrNHVMHrlVrPSMNjHH
+gspgFzRCFWLJpgqqRWgqpCJwnQCnhQvwcTdcdddnwbDfhf
+fMMCwFDGNNMTdTDLlVlZZmdZBdBtVr
+jjpjtbpRcPvSPnPnpPnvPPPnbZlmrWmLWHmHBWHlrmrmlZWl
+jqjjnPqngtQfGFftFq
+qnzhhbzzqGgsqGtnwcJrlCMlCjvcCCcrCRrvCv
+mVSNZdTQdVVWmVFHQrpCjpjDRvjMRjdLRt
+WBHZTHHTFWWNNBNHQTZPsPggghfgsnsgsffthszJ
+sDwpdMgvHrZgwbdggzZZgPhFNFFcjPPqhLhjMlPqLq
+JffJfnJGtBtCQQRBJZTQJJGfcNjqCLcFhFWCPLjhFLPjcPhl
+VZZVmtGQQZmHrwgddppb
+NNNlpjbVpGglNbvpTwBQQvfWvfBrWvBW
+JthDJsLhhHPcGcqPshJsshSBwCWwfWSLCfSfSSRBrfWB
+dhDtZqGmctZDtZHqDGVgVgNbbbFjndMFNlFg
+jqDVzzDMdDwsVQLCZVCRWLGBQC
+bbHFbSSpFbFHJHStJNbtJprZlCGLQsLGZRBLRQLQpLBClZ
+SmFmTPJvFTNbmmsMdqqjscwz
+RqMbHGJRJpgJgGgQjgrLTrTzjcrTrrLg
+lwfwdhnflPlbCsVVjhCSbV
+fwnNtwmlFZpbFZtM
+QNSQrLTNrLNQRRrfHFrSjqhblWtSltqlWqtWWl
+DvgBgnzgcvVZMljv
+DGJdjBPDngDnDjBpBmFpTRmRFLRRmmCmHH
+dtgSdTqdlvdJJvFqTvSqJqqRMPBtLHPBnWbsbWbsbWtWtWHV
+DjfCfmcpNrwZQCmmNrDZNZNpsHLHWBBbHVVcGGGbHGBbMVMB
+fpNjCfzLNZjTllvzdSgFgJ
+nHBfZmHTRwsZffjBnHfmRZHtLtdNPPlWvddWLWJlJldCldLC
+zwrbphMMVFzMwdCWNPlCbPdDCD
+hccMSpqShMSrhZTBwmTqHjqZmf
+NJGGLwGsTSsNlJZhmtgCVlbWQWlQMtCbvb
+pDjppDBRdjzqpHqDSDzjVMCCrCrWtgQWdtdQQCdb
+fHpfRBPRzDpBFSqcSBRBSNhPNwwNNswJLhmmLNGJZL
+RZbsPgnVDzTJcdGjDGmD
+NwfQHQtpfppQhjVVjqVNJJTN
+tLLtwSptVCSWpvVtRnrbWbMgFPMsgZss
+VsQjSwwVSwsZzsvdscZvfrhPRpqBrBrbpzMrrTMh
+JtNDTmtGJTmLCGFDCHtDhMMBRhqqRbPrfrbNRrbR
+GDWLlDnFgZdTSTWv
+gfQHRRpQgRqNSBtjqwjztzjtnL
+FvsPgvDlFcmvmTLlBMVztnLwWLzL
+cvZGDcvbPcmbTbrcDDPgvbTJdJfJHRhZSRSpRRfHdSpSZd
+FGHHHWvBWrHHrWVZJvVtcSrtrTcrtcjMTjStSM
+swpwfRhRmmmRQDzcJlcqMSMMqtbMTz
+dQDRDDRQfmmQDNsLfwRJvZJWFWVnPWvvPddBnC
+zVhHvhMVTnMJgcTzMcfGJtfBWRtBRqJWtqJb
+hlZjZSQCZtfBbGjqbb
+SQDNwplrDVnhDcVHgT
+HHZmttZVLVMQQJwMfcDRfDbbMN
+phWvTgBqqgBWsTPTzhWzhzfNGNNwfqfcDwJRRbNcJcbl
+FnTsvnhppTPFTBpPzPvpBBpFVmtfCjfmjtCmFdStLmtdfjSd
+hMTPPMNlLZNSGNbRBB
+gjmrsrttsCnsCsttVsjvttvtZGFHdbZGWWWdZSWddBHHnSWH
+BmvptjsrfjBgsvvfgmfQchMpMqqhcQPMMPMhLQ
+dJHGnrJJpGpDpFzzDmfsfSSCbfTfMbbRDb
+vLcwtWNgtVtSNWmTmTMCmhNhTRfM
+jqVgqVvWwwLwwgqZgjVSrPGzHHHqFnrHnFGHJGdr
+QcQcdgbzwJnzfgVnVwdHQbdBrrpplHvmhLjrlTphppLrjl
+MsPssfSZMWGWqWssSNPqrmmLBvjhqTvhjBprhB
+GRDDZMFNMGFCSNWFPDMMFWNnwVtdVdQfcgtddwQwzRJfQd
+pMqCMBGpMMCnwnpBMGBlbVRFJFWsJzRdzHlWzzJdJsJd
+jLLZjDgPbNPZTDbvftvZgzRFsRzRrRRHWFsJsFJc
+TZZLDPjtmDmbqQGwQnVM
+RjnNhBnnNNmJmBNhrqGpsHbHtstgTtTjqb
+WVMfWwQTzWZDMtlsfldqpplstf
+WVTWSTzwQWSSvQVZCQPTSZPvBcnmcvnrhmNcRFncNLRLJmnB
+lffQcnNTQBBcwqsdcqjSspcWtD
+MPMGrHGMMTqWTtDg
+VGRGLrJHZzLHPzTNTmmBfZQFTNBQ
+lQBPPrBrlnqBgSRhgZZZrLJr
+VNcWMDZbJHhWfWff
+VwvMwMvdwvdwjcwdwDDqsqsZQqPPzqzldPQtps
+VVJcZJVrRSdcsddfsvvbvFZBnngBMzMZFD
+hLLqLpqqWWphWjhlGlCHDFgzbvFBbgBFtnQpnngg
+HlhlmmHBTqTHHmlLqjTGhHhPdwdmsdcSNSfNJRrRcfwVJdrr
+HmhvmRzzHHrRMBJBjNJGDJRnJD
+cbqcPqLWZwsgQWZwWPwWgPPbntJnrNftNNNBtNJJNDBNqdjB
+lgwWgggQcWSzrlTHMHlp
+FZhQpClCWLBlrNDZvrwrrNSH
+ztTfjMjJjgsGrqvzDGwG
+bMjfnjndjnJtfgMTwPjFhQhCLdQCFWQQLWQhch
+PtrqPrrMCPChzCtLFRbtNgbdTjbF
+GdZGvJSWWDGplFjbjLjLSTlL
+vspvnZsVppBdBnBpDCszhzMsMzzPzPhcPC
+PdCtdfCMfGmtfmtBSWrMQwSlwWwJNQ
+qTqbcjqHTZTbcDqczTjjZvWrQvVWJQSVQZZSVVrJNr
+qbqjRFTcHTcDFgcczRqFrPsGGGgnhtGssCdnffGmsP
+vVbcMvqjjjmHCBCBBmBSSH
+PzzLTrcrwQgfLGrJBHSGFSCHtRFBJt
+cfsPrLDwQNgsrTNTQgLwVpWnVWvMNvqjjqvpMvlj
+jbqZNjLbZQvcfhhQ
+CWdCDWWMCgmJDnJmdQVzMSchvfcQVFShzf
+WPgWGRWRHdPBsttrHvNtrl
+MCJCCMCqcCqJsnssjQRlTvQQQQqTvqfQ
+HGVmwmLVlZRzcGZG
+FcchHmDFpFbDMDMbntsJ
+vfNvvttvDRcrvRNRNTLDNRcVsFhwVBVTwbbFFVbVhbJMBB
+CJGgSJHdgPPSnQnjnddHGGFMSMwMMsmsFMMFhFShMWMM
+dGCdjgzHCPPGlHDDqJtqRcqJlpfR
+CwtqqvwLwnwhtRLtdRnwnnRhPHpLLppTPPpTVfTHzJWVLTWB
+sGDsZDllDrMFZVmGgsmDMlmHpJBHpcJFPPTHfJJPzfTHWz
+srgVlGSgZVGGrRvwQwdqwtCvnS
+MLPgDrgLzThhCTgg
+GVfCbvVbVvhBHlmhvhHv
+ZqRQffRwtNZWVZfZSMsSssncnDCDnL
+VwBNhNNmhJswqjJsRzPgDvSgJvtgvgDt
+rRMblbHFfRrSWvPPPgMzLW
+ZFpFpCcprGfbrGfGCHclZfnGqmsjmBdNVjQqRBnqBsVNQwBh
+VLQlZWQbcPgcPmWbgmDWLQzdpGMTTqdpMTNsbGsNpMSqdq
+HChrwfffhJtfHwJTsDqThhDMpTGsjj
+HvffCrtBzclQZvQD
+dCBVJJmrJDlBdQJWZTTsWbdWThWpbM
+FHjSPjwqwssSgqTMGbGWhTMHMMZG
+FwLvLfLjjSPqFqgzwffFSvrlDJvrQrDVrnmBvrJsQm
+hZCRbddrgrRSVgcGZjjLFGLZFQFp
+nzPvMsPvtmvPNssPMqpcWVjGGcGLlqGcGN
+TBzmTmzmVmrBSBRrRgdR
+bwZZmwfFmcfCRswNWNBsjC
+VDSdglSStRCCTNCD
+VVVppGHGlrQnnGJbMmnmCh
+nFhgnFVNtgtFVssgdgVtVtsqJPTNJvDSNqTZZzbzTDDzDq
+HqLHqcwlBjLzPvPJCCvJ
+HGrlHqlllHBppRrlwWFnnWfFFVhMnnWdFhfn
+FsMFVszjggMMzWlPJlPPlLQsJv
+nqnBSNlfZqSvLHnHvWLQTW
+hShpfCCSRtfjgFjMzdjlpr
+jsbDsQnnwPsFbZgSltWGdgJgpnSp
+SCVvLhLRrzCNBhrCvddMJpWdWGvJGlgtpv
+cHLBBVCcCNHrbcSQFwQTbDws
+rMlbLgrRgpwTDbflcnHtSScwHdJdwHJB
+CQCjjZPzGGzCzZQvBVBNdQNSJVcJ
+jsPhCzhPqFZzZzChFlsbRRLrMfTbbcLTpD
+dqjzmmmQBjBHCmWrgVGWrrrvrpgVpM
+PLJnTFbJnhTDzrGgMlvrFMzF
+SssPcDttntDSsLcCzHBmmwcmZQqH
+fFfFSPHllPRpRfnmmFfHvHjgbsBQjsptBdBTTddjsDdt
+ZqLJCLCZzzTgWjdzDjzb
+ZhNLMrNcGrchLqcCVMqRvlSnFnRnmmGRggnPnP
+HMCMCMrHfwMHtFwTtgHHbVjjbsRZDwDVRbZqjhBD
+cDpmpdpNLNDcdZjZqZBNBqssRR
+SLJSdPcznSvdvDcHFCftFTFWCTHnWt
+NlMmlPClmdGldRZHJs
+tgJJcJQcntHBsnBt
+TfSgQhhccczSVQqrgSgTjFWqLWmwLFNJLWWPPwqM
+GGwTHqWVdnTTVVqgngzzqHzGFbJspFccRsjDpDcjsRFDsdjR
+rtLflllZSrhQPLBtQStZvhjDNjbcDNDRNFjCsCDCFs
+mPLBQPtvtQZtBlLSmMqVGwHbVMqTHWmz
+VvJCrqTvPvQrCpRNVRFGfZfmfG
+HMzsdWsjhZSsJJZNZf
+wHlbjnlzWCvqJBQlrD
+FnVRRsVdSnSnFSRqTVdqBBDBhrDdmcddMcMQMhzm
+HtZvJwHlgjlGlHJLNjJrMmrcmDQfDLczDrMhhh
+vGGpJjttvlZljZllZvJZvwGqsSTRWSCpnCWTVPVmWWTWWn
+wSHCNwwmcSMLSDFcwwSSHQvZnQjLZffZjZZbVZjVVb
+JqsNJJGGqprJNtpWhGhspfnffTnTvZvVbZnTrfBQvV
+GsWhdGtPWpghJRqhtNPmClczSlDglHMlczmwCH
+TzRpjVRjFpVLTTdgrTgrGsZwrZZwgg
+vQfSBdbDbMbQNBJrlhmGnrgrgwZhvm
+SHSCbdbddcVWqqFPCLqR
+

2022/d3/run.sh

@@ -3,8 +3,9 @@
 # Runs deno at src/d3_deno.ts with arguments ["example.txt"]
 echo "example.txt"
 deno run --allow-read "${PWD}/src/d3_deno.ts" "${PWD}/data/example.txt"
+deno run --allow-read "${PWD}/src/d3_deno_concise.ts" "${PWD}/data/example.txt"
 
 echo "submission.txt"
 deno run --allow-read "${PWD}/src/d3_deno.ts" "${PWD}/data/submission.txt"
-
+deno run --allow-read "${PWD}/src/d3_deno_concise.ts" "${PWD}/data/submission.txt"
 

2022/d3/src/d3_deno.ts

@@ -1,6 +1,75 @@
-if(Deno.args.length < 1) {
+// Usable by Windows and UNIX
-    throw Error("d3_deno.ts expects a single argument that points to AOC's day 3 input file");
+const LINE_SPLIT = (/\r?\n/);
-}
-const fileLoc = Deno.args[0];
-const text = await Deno.readTextFile(fileLoc);
 
+function priority(chr: string) {
+	if (chr.length != 1) {
+		throw Error('Expecting character');
+	}
+
+	const ord = (v: string) => v.charCodeAt(0);
+	return (ord('a') <= ord(chr) && ord(chr) <= ord('z'))
+		? (ord(chr) - ord('a') + 1)
+		: (ord(chr) - ord('A') + 27);
+}
+
+async function main(fileLoc: string) {
+	// part 1
+	const text = await Deno.readTextFile(fileLoc);
+	const prioritized = text.split(LINE_SPLIT) // split by each line, basically iterates through each rucksack
+		.map((line) => line.trim()).filter((line) => line.length != 0) // pre-proc: remove "falsy lines"
+		.map((s) => [...s].map(priority)) // translate each character into respective priority
+	;
+	const sumPrioOfShared = prioritized
+		.map((v) => [v.slice(0, v.length / 2), v.slice(v.length / 2, v.length)]) // splits by 2 compartments
+		.map(([left, right]) => {
+			// Finds the value on the right compartment that also exists in left compartment
+			const left_set = new Set(left);
+			// by the prompt, we're pretty guaranteed to have a solution
+			const shared = right.find((e) => left_set.has(e))!;
+			// console.log('shared:', shared);
+			return shared;
+		}).reduce((a, b) => a + b); // find its sum
+
+	console.log('part 1:', sumPrioOfShared);
+
+	// part 2
+	// eventually was not used. part 2
+	const setDiff = <T>(a: Set<T>, b: Set<T>) =>
+		new Set([...a].filter((e) => !b.has(e)));
+	const setRetain = <T>(a: Set<T>, b: Set<T>) =>
+		new Set([...a].filter((e) => b.has(e)));
+
+	const groupBy = <T, K>(arr: T[], groupFn: (e: T, idx: number) => K) => {
+		return arr.reduce<Map<K, T[]>>((ret, e, idx) => {
+			const groupId = groupFn(e, idx);
+			const last = ret.get(groupId) ?? [];
+			last.push(e);
+			ret.set(groupId, last);
+			return ret;
+		}, new Map());
+	};
+	const toGroupPair = <K, V>(groupMap: Map<K, V[]>) =>
+		Array.from(groupMap.entries());
+
+	const groupByThree = (_: unknown, idx: number) => Math.floor(idx / 3);
+
+	const threeGrouped = groupBy(prioritized, groupByThree);
+	// console.log("threeGrouped", threeGrouped);
+	const badges = toGroupPair(threeGrouped)
+		.map(([_, group]) => group)
+		.map((group) =>
+			group.map((bag) => new Set(bag))
+				.reduce((left, right) => setRetain(left, right))
+		).map((e) => [...e][0]); // get the only element in the set for each group
+
+	console.log('part 2:', badges.reduce((a, b) => a + b));
+}
+
+if (Deno.args.length < 1) {
+	throw Error(
+		'd3_deno.ts expects a single argument that points to AOC\'s day 3 input file',
+	);
+}
+
+const fileLoc = Deno.args[0];
+await main(fileLoc);

2022/d3/src/d3_deno_concise.ts

@@ -0,0 +1,60 @@
+// Usable by Windows and UNIX
+const LINE_SPLIT = (/\r?\n/);
+
+async function main(fileLoc: string) {
+	const input = await Deno.readTextFile(fileLoc);
+	const ord = (s: string) => s.charCodeAt(0);
+	const prioritized = input.split(LINE_SPLIT).map((line) => line.trim())
+		.filter((line) => line.length != 0)
+		.map((line) =>
+			[...line].map((e) => e.charCodeAt(0))
+				.map((e) =>
+					e - ((ord('a') <= e && e <= ord('z'))
+						? (ord('a') - 1)
+						: (ord('A') - 27))
+				)
+		);
+	const retain = <T>(a: T[], b: T[]) => {
+		const bSet = new Set(b);
+		return a.filter((e) => bSet.has(e));
+	};
+	const halves = <T>(a: T[]) =>
+		[a.slice(0, a.length / 2), a.slice(a.length / 2, a.length)] as const;
+	console.log(
+		'part 1',
+		prioritized
+			.map((sack) => retain(...halves(sack))[0]).reduce((a, b) => a + b),
+	);
+	const arrayGroupBy = <T, F>(a: T[], groupFn: (elem: T, idx: number) => F) =>
+		a.reduce((ret, e, idx) => {
+			const identity = groupFn(e, idx);
+			if (!ret.groupMap.has(identity)) {
+				ret.groupMap.set(identity, ret.groupKeys.length);
+				ret.groupKeys.push(identity);
+				ret.groups.push([identity, []]);
+			}
+			ret.groups[ret.groupMap.get(identity)!][1].push(e);
+			return ret;
+		}, {
+			groupKeys: new Array<F>(),
+			groupMap: new Map<F, number>(),
+			groups: new Array<[F, T[]]>(),
+		}).groups;
+
+	console.log(
+		'part 2',
+		arrayGroupBy(prioritized, (_, idx) => Math.floor(idx / 3))
+			.map(([_idx, sacks]) => sacks)
+			.map((groupOf3) => groupOf3.reduce((a, b) => retain(a, b))[0])
+			.reduce((a, b) => a + b),
+	);
+}
+
+if (Deno.args.length < 1) {
+	throw Error(
+		'd3_deno.ts expects a single argument that points to AOC\'s day 3 input file',
+	);
+}
+
+const fileLoc = Deno.args[0];
+await main(fileLoc);