From ce897461313035bf0e4806d1c44ddc806a1d4e54 Mon Sep 17 00:00:00 2001 From: efim Date: Sat, 3 Dec 2022 08:28:00 +0000 Subject: [PATCH] day 3: strings as sets, loop --- day3-input.txt | 300 ++++++++++++++++++++++++++++++ day3-rucksack-reorganisation.lisp | 108 +++++++++++ day3-test-input.txt | 6 + 3 files changed, 414 insertions(+) create mode 100644 day3-input.txt create mode 100644 day3-rucksack-reorganisation.lisp create mode 100644 day3-test-input.txt diff --git a/day3-input.txt b/day3-input.txt new file mode 100644 index 0000000..02370bf --- /dev/null +++ b/day3-input.txt @@ -0,0 +1,300 @@ +GwrhJPDJCZFRcwfZWV +LjnQlqNpjjmpmQlLlqNfZRvQcTWcTSTTZcSQcZ +nNqjdspspngnmjmslqmjjjCDGrHPHMGddGCMCGPPPJWC +GwmVZmPWWFFmBbVbZVwmbPsTCnlgQgnQfhlffffZnlQh +DqVDSqqSMzLLDDNSHHLdqSdSllCQjsTlClhlflnTlhjgfgfM +VHJztNLHGtcbvvPG +bjrPrNCtNrjdcCPpptfpTVspDtfTtB +JGQJMJQMmmmZMnnLpLBTpHCD +WJJqWRgWlCJZhZRCQZwdPScdrPNbvzPzwvqz +QNSQNBWQNLjZBNNhLhSNRsTcsrTTVzcwZZZsfrrbwb +tCFtHpppppMldpvpqnMFmMVGrbPcrwbzswrzcccfvTfw +pdmCpgqCdmHHdJVWgSRNJDRVVj +sNrFnvNSzrjQtQjQTj +lcPmcJDLdPDbJPVLljdGGBBThBQTGwTtBw +PDLqmJmpJQfFqfqsCM +BnhctqdnqnRcBnslCJJCMrJrsG +wNDMZpbQwMpCvCGVjlss +WfzNwZFbwZzZmFZbLzNwzzzzcdqgRMTTPdHPTTPMRdcWgRPt +grsrVSFSSdFSDFVFjZZWwpWpZWZplgZZ +mcBPPPBLBfNdLlvvWljWJC +dMcmcRdbRzdVhFthSsTShM +bzvJZMTzTZSHLCCdDzmDcc +hqBqWPFssvshWvvssNqtsHftmfpHfdcdDGHmcpfctL +WvBQgNNNhghTJbJQlJTZlT +chcdwNwdbCbQctCjnnQGHsQspMHMjG +nSSSJqJZzJgWWRfZDJSnqvTTsVvvHVPpHVfpjHMTjP +BZRDRmmrDWSrZWWzWSRNhdnCFwChclFtwbNdtr +lNgmssCtqLwqCCtfsCLHPFhhhmMhVzBDbVzMDMVz +ZnRlQTlJzFQFQFVV +npZJvRRGZSnWvSvrSLglsClfpfcLgNgpHf +tVtqcVqFVtZhcfFtqlgSpmpDSDNPzSzZmNpw +LRGTHqbrHdnGHrTCSSwNDzMDwPMzNwbp +TqWGJrGHCHnTWnhsWcFthFjtfQch +qNnTbwtctvffFcqfrHjMrFjVHRjSjZDZ +dLLzWWPmCmCzGdsLgBLGGBDRMVMHRlrrrZDDZsNMrNNS +PJQWggCzWNWJzGWfchvfTbJvfnnwtf +ghzdgzzdQsdqzzhMNqQzvhgQnRRBWTjWWGTRGWwGTZhwGnBT +fsrfJHbFfDFLVLVFHrWCWrBRZZTGCCjwWZ +HLLllcDPbLPQdPspMNgvMt +fNDJqdPNbtHpCbwpCCCp +RTMRLrzGrMRMRPWnnvSmgCHFCCFmmT +WQsWQjzGWMsGQzWclQtVBJfBftNdtqVPfP +gbTCVVmDVFdsgmgrrcfwlwfTfPlcRR +qhQZqQvnQhLQhJnvfPcSwSwlfjGcqjqj +tLNZLZZJJZthpzhMZDCdFmFsmWWmtDDgsw +bqCvLvLppzPzPPvPbFztFtttBNGdGsRggSgGSHDdggHSzNgH +rMQpWfMfrcTjWJhwWHHsSBsRBdSTTNBgSR +VwfmWjwMWwccrWcWpQQFnFtlCqmltFnFLbbZmn +cWqsMWJMzqJJMHsJcqsJqTqjSbLBdfdSbtzLbbLfbSfShfhd +gplGvQmRrCrgZSZtSGZZjhbj +CQmmmmNQRPvjgRClCvmmcVHPqMFMFsWJVqFFcnTJ +QHHqvGwjjWNqvGTQGvTFcGwJRJbszcPtDbJVbtPzVbDptp +MLdrgmSgZZdhdfbLVRpszlRDstRL +gdSgMCSfdMnrghCWGRQvHwvNHjnjvv +RDBZwvZBrMlsvnlb +WdFQqdjWWcHHPrwSPnnSWnSS +mLdqgqHmcjHHjqLHjLppmhfBfgtDtBJZJfVtBZwGZB +CCWRJQnZlHtHtNZRFDcBhrcvhDrJVVDv +dPPSqLzfsqGLSTzfLzLGdLMVVgvBcmgMVwmmDFrVgmBBBr +SFjdTGzqpjdRbNRNnjtnQR +hjNcwBDDwDFcjdFfjtFhtcRsGGgTsGRRRTsGGqZGRq +gbmrLnbzLmvQJnQVVpqZTqzWSCRpqRTsSR +MQMvVMbPQQHrQMnMPldtwNNfgHtlwBhdwj +zwzwpzMfzrBMWfCCZrwzrMJDGGGnNmGNZvgNZsDDsGsG +FbFqSbcSbSHqTjmgGFnJglllsDJm +TbhVdVjqdtqTjVHqjPdthPBBWpCnRfwRPRCfBCCnWR +hlpmbfJJpCSChmJMmrSjTjcSdjTtQQTtTtjF +gqrgsqLzgnBgZGzHBnnsQNNQtjjcNNjjtNFQNcNH +LVRzgGGzzzPCVrJMbPJb +VHrmqFnVdvlzzNrr +PMtwBJPBcPwfbwBJndplLvLdLlgMMzLL +bBZnTwbtnScfQJPJwPTjqGZFsVFjDHHGhhHhVj +cftqScHJrfVfrrRZ +DTTsDvvlBbTGrWBwwsWDBbWdVpZjjZjpVPPGhRRVjVZNRPNN +lsWdWDbrTLBsbdrmdwbMJtmHMQJccFHFnJFqFt +SWNPTPVSWChCSmQQhpppJdFJLpDpgLJmLd +NGGtNtGfHtDpdJdqLB +NcsNGNjHZsZGnzZfnGhQnhPClrVlQPhTVVhl +QDdgMBsNhhMgcWbZdzmWLzFzWH +fRqRJJqGCvrJGjCRRrSJlfPtHzzPmfFbtPtLZZLnmt +VjvwwjlwVGGqJSSqJFccshpgNhQNQTsVgBgT +wvDLDwCbFgSTfTSJJgfB +qsRhmhqchmVhPdfTHJSzpCtJpfPf +hmdhrWrddmhlqCRcwQjDLMQnMFDZnlLl +trMWtlwwMplMZMCZWltDpzBLBnflVLBbHzbBSGlVlL +ghhqJTfmjQjfqqznznnHnBRzBLmn +sQhPQsjjQcQcTsPqZWwwZcFfWrWcrZww +MRVpVCZZTHWVMCHvgNvVvbQSqgQSlg +NFmnrNDDfnjFnndfssmcStvjvQQlvzvllqvwQllj +GGPNmBrFNdcfcGrsGcdmDFhJHMMhHLZJMhpLHCMMMMPJ +DSvDGdGFlGGnDZFdVSZvfPqwnfhpnrqpPNpLPrrh +sWcTjtHCsTmsCNfgMPjpfPhqhP +BtHzBzChzBBvFSDJvVzFJJ +sfsNrsFFBTfjwwtNNWHPVCVWtSCDDCDmmS +zMdhMMZnSccMmmWVWmCPlC +cLSScJZQbcvLhZvnzBwfTjrpNwNrBFffpb +TBrCBgrTngVQBVbhrCtgJJrGssGsMGRGcjMcNjfN +LZdSLvHMFdzFRWsLjcGRWWNJ +pHpzlqPqFPvdBthgMbVPDhgh +SZlnZZvBvvMrcBnllBMZSvhGMtQwFMGztthfwQtMwwPf +HLqsDgNsDLDDDjggHDHszthzFbQGTghPGQPbTfFT +dmLqDqCmFNjJsjHdssFNHDVWZccnRllnVZvRSBZrZlCc +SccnnSGGftShfHSHHhnvbMjvVlCjzbVzzbMMTbCB +gRpppNNQLWqZgPZwNWwwBMBbDlZCTzVTjHMMbBjV +dqNQPQRqrqpPcGtchhdfhHSF +mfDzgnNMMszBtJCpHlrjnFppCdHj +LLRThGGZcbClBQpdWFGl +bSqVTbBbMVMsNmNM +BTTbbLVpfchmjbsj +JSQJHDMHqdNZTZlhFFhCFFrNhNcsrr +tMwJQlwMMlQwDDJtWGLGPpWLLGnTPn +LcVQQCPPLqTzqQTcllTzhnHHfFJRcGHcFfwRGHwJjJ +stdWDDBtVgbpWgZbsNgDNdWFGMnnwHfjHFpfwwMGMMGRjJ +ZWSDtgNdWNBdgsdsNDDsdbDlTzCVSTCqQmSqTQSvhqLVQq +dZbgdZbNtmqttFJtHHzcczMcFszHnsvH +wwpQplQQwqVVjqwPjCGCSMCMcHSHvvzHMzvcsrMc +pfjlQRpPRRLQWtmLNdWdmqqJ +CPTPPmbjmVjVGCvzbjjPrGsnnMpttdtGdncdMccDRd +lhlHzQSHwzhJLwgWgpMDMMsDdcDQMDMMns +BHZghLWwSFBJJBFvzmbfjNZvZmCvmb +PBGcvvcRwpwNcZcNPpPNcTHGdMtrCWrCCtCLWMtWgbVdMV +fmsJjnqmmfsjQJnjFzSFSqsqgWrtMttZgMWVMbbVMdbSrLtr +qQjjZFmfjZhZmwcvPhNpTNBTwN +HHlVVmmsbbqMsJmVzGSBMSrQQrRrGvvnDn +PZcphZPPZPhjcpdWgPZhRPfcDSrtDBSGNvtggrQtnvQNGNDn +dcWwFjpcPhRcCpjwdCPLzHblJbLbzmsmbTwzqH +hRfzTTfRrTGzhGWTrRrbfcQZQSttWtwddJtvdJJvWSHq +npjnDjFlpDnFFNMjljCnFMQtHHtqNHNQJwwZZqstNwJJ +DCjpLjjpVLDMDpVLDLQbbhzBhVrcVgVGQQcz +LncLBLjCSNrNrNpCLQBBBGwqQwzlzmggvqRqgllmzwtv +fMZPHhhHfthMdbRgHJzmVqlvwlwg +hfsPbZFPPDsfGLcBtSFNBSjL +MlZmszBMJBHrMBMbShwSFpbZSZfwwb +TCLCcPNGTgTPNGWtCtcWtPcSsRfRjRwjFbfpNFDjwsFspw +nVtqqsWsdHzJHqmM +RCrhSmWrmrvmrvhMvRNrRCzCJcQQbPtsMZVGJJtsZssPcQcZ +jLFBGqLFpqBLgZVbPbsLJQcbsV +HjDljGFwrRHRRTrS +GZZhnrwZBwNjRPRCbCbn +fJtJJpsVfpgNTbVNFTRP +JJcpLJfLdcWLdplwRdQMBvSqwRhvrG +wmZDPlRlCDwglgsHtsBvdBHLFLSddr +VbVMnMftfVjQWFFHdMBdBFMFHr +zfjtnGqqnjGqfjPcDPlZPlRDzccw +BRjhfhvRgnTMlFDDJfZzZFFQDZ +qLdqcNttwwcwwSPSpqLNmrwmrZsGzzDFZGZFzVssrzJGnsQG +wSNdHScScdmwHSpdNcmmtLMvChRHbvBMTBnCBBvhvlCh +JgWTPfFPgCPPlCntQSGghHvQnSdQ +BzvMZvLVQpdQpSZh +RwVVjRDVcRDNDTlJPqTv +SGHSrBBRPhPPHQcTccQTRRQjTN +vvWvspCbzWVWVrWdjj +wZpDzCDgDbCZJZzJGlrlqPqnqPllmH +FCncCrDWMLCbjMCcFpLdzZfmZzwwWzdzNRZdWB +sqsgTqHSqllNldMwlZzJ +MtHPTgQhvhhqcrDrrDpjLCQc +pPPvmPWSClqqPvqCmSwqmgGBWDjhGLHfjhDLJGjBBhNj +zrbdcdMndcRdTrsMcbTRdzRFVHjLjDjNLNHsfDhNGjhJNhDj +RdFFcnTdZcTrRRdFFbZtwQCPQglvPlwJwQPZSqqP +wlmbvwmvQvWQsvmbsSsQbswlRCNPfCTcTRVCffPtTSCPNRVP +FhJJJFgFqJGBtDpJhTTcVcVhdcCdCdTV +GDFtgLFnqqDGqGZsQvsllrjbLjbrvw +lnFSnJvmgvLlfnJpgnsjnjgfDQWqCJqZdDtDCtCtCdDrtDDQ +VTBBMPFcNNtMZDMW +VTGbzGGhTbTGHwVPvvFnfpvjgHnfjppp +JJwHqvlvDjljDwJFlZjZDwHNNsMqhNpphNpmNVzpsnsnRV +mTLgrLLcLSTTTdmPPfrrrnssNhRNWhgngzMWzgzVnM +SmTfdSBbBJbtjJvljl +bPNLwTCLLQQqtJsf +zdnnZVlWWGGRWGWdgdSStQMqJSMRptftbsMf +FWbvgvZZZZgnTmwrrhrFPCrP +HcGzzszFGllHWHbZspHbHGsHTwwrTrLLCNjSZwNjNjjCCNLj +PBJMJQJDDDnDggRhMdRSLmjTmTwwVjVQSvvwvC +RqfdhgDPDJDqJJnBdfzWWHcstslcbtStfHzl +zvRRlCqrdNdZcZpjBpVwjsmjsm +fgbTDqbhGfDnLDnLLqLhFmsHpTPHjHppppBwpwws +nhnnnDDngDtDbfSbDnGhhgRlNvQdQqNvQvtcQQNJRNJN +cZbCcbbScCbcmPGjPfSBQQSq +lnMnnVsMVvmzzGMDzPDf +LhrTsTTglrnsrrWWVvlwTnNtcpZRCmhtbCZFdttZbRCp +NWrFPZVWNVrvvrhtnNdddtpldmjm +DcBQBDsJbCwQnbtdzmjjjljbpjbz +qCDcGsDJGCcBDBcswJnBJQDfWfqgvZSvgZPfrVSWvPvZZZ +vcsdHdGtHtMHMFtVsddsWCcbppZwjScLpWhbjRWR +NTwrnzJrgTPrDwnlphRpjSpWbJJLLZWj +TlDPfPnzzlzTBzzvQFFBHMtVtqBqqw +NHnqqfZvZBNHHvgfrSlJrJCSllJRVrCn +TDTdhLMWjFcddMJPSSPJRmlCPz +bljWFdLLTDLtdFtLlwZvqfbgwwHfwqHNvw +BRRjhRQndRNVqBjRVhFLccjpwMmLmjHmgFHH +fZJfJvzPPWtWWlltZzZPpcgFMsFFwwFdpHdgwtdw +PCrdrzzfWCPdvSlqTqNSDnnQVVQQGT +DjbfBMDSfBljBsLSjSZbzrGtPtMCPtVPvvqrzqzG +mWdJWcppcNTdpppjzjRRVrPRpq +QncmnHwmdTmwQcmjNTfgfhlBShshhsffnfbB +WGDsMJsrjHCWtDMGDDVQqSvZqfSJzSnvnvvv +LgLFLFBFLVVzfBzMqZ +lgmFcwLhNcwdwwMLwhmcRDjNpCWRsWRspGGssHCp +PnPzNccnjFfvCvhbSBVcWqdhSVhV +psGMDQJDDDJgQNDHHJbwqwBsVqqZVWBBhBdd +DlDJDQGptpgpGDfTRnrTrFPnNTlf +MSSSMLLmFHcDScSq +ppZnCsbjPZpnnJcbRDmzHJqRRD +pmNmnGnQNnClZGMVMdBGrMgVWg +lsTTGcQzBcljCcQzGcGjGptttpmvSJtmggtwwswwtS +qZRnrhMbRVdhZRhhdnnVRPbmwSNwNNHtmJBvwpvtwNSvSb +VnMrqrrdqhZrnrBLLlzzlQjQjLfTcGfFDF +dJJTlHvhZqZlQTJnSgQDzgsSbScsSBzc +RRNtGjCCpRPPpRtjfrttRzmbscLsLZLgcsbmLzSGLB +wfNttfNrtWwPNNFfRtpfrdJMTTTZTMZTTVTlVwTlvM +PQTGLmdNTgPmGgNNdCPLQlrMqBrDzMCMFqDqFqjVCBCD +hhRwwvpSFmzDrmFh +vwwZfSfsmvtSspnZLLLdLGWPTGTQtTWG +pMcWzWFvWhFpPMWzvvhpdprHTZTQrHrQdZTJdfTgQTnJ +CGbjBbNjjDmRHJDgrTVVZg +NNttGlGqNLsbtlhMFMFcMLwMvvZz +CGSCBNCQBtBCQttBwCGtGtQrqrLrJqZHLHbqHvLDHLrq +nVVhPMfVdfVPbfqLLqgDDqPvgZsv +cpVncbfnhFcBltTplpmTBC +MrdcdStbMnddtRBdqMnFmbqGCwqCVHVsNHwPfGVPqsCsCs +DBLllzWWQQzlZVVVCsGWHfsH +JQphjTgBjlLgjjpTpLgvTjQnnnSJJRRFmdbRRSdMRtmdMc +QbRZMSWMblwLsgpwZzqZ +BFncBrfcdNrrnVrNjsFzFTJpJLGJsGqLTp +VjhDDBdrfdhQMllzHmPQMh +LdVVjFVFbpVGRQGllG +cNMcJNHzJWJtCWHNJHcHczWpGmmhMQmBBqrlRhBmpGpGBQ +JZzTTtCZtHCJnNnNwPfbFpnfdDdLdnvP +TpMlrWTTddjmlmDmgQgRtw +MNNVMSsVSNSnNVMFLDqwtGgRRtGbgFRwtR +CCLSCPSCZZHVCfZscBJJhPphpdpprdhjJM +gSMSHJHsMMpzRgHzsRMPPSzsPhtZtZdqdDqQDhdCdZmQldht +FCcCnrGcNTfvvtqqfvlflQ +TrTrWNWwrTJLMzJCzWLL +TpTzwMrfbrpFpMbFrrrzbPSdZmtSZRTlTZRlmdCVlCtJ +vqvWgqDJQJsQCVtZgdZdRRGd +vsvLJLchWBcqnvczwjLfzPjfrjzPrz +zqzbqCFZgmzzmNmf +vpRWSbRVbVWddVpwvwdRSwnSNgLHsnfNgMmgMLMmnrns +DwWVpJRlpdbpRDWdGJGcGlhFtPPCqCCBFqZPQttlqFBq +wQRlwtBJBDwttJdGvLfBvHLLfTLz +MMmNZcMrcMFnRHzfjjvvHfvc +FggpbFnhrNNrrMrMbMbnhQVJVhstJwqWCVCRsQJQ +DQbCGblQlpQFQlHjCbjwDQQMggNmJmgnnpRBngfZmNgJMf +zvhWccWVdWBchdssPrrWZZZfmsmmmgsnZZJRsRTf +zBdtqPccWPHFCqCCqljq +ttrbRMmgtHgfmHSfBpLfnBBZBppB +CVTJDCCNPwCPDwcqzmddQZdTQdnLBQThWp +zwFDjwDJJPzjzVNcVJwCcbRHGmbbMrFHgHvrsgbblG +gZjjwHqHCzrMZVVR +hhzcdTzPrVhVCGMb +fPcmLPNffsccJDdNDjBnpwzmHqgWjHwwvg +SJQFSvQBlzbSCgdPPddPPPSN +pcrjcWLwwcHcgPNgTPLMNTCB +pRsjsWRnrpHRmrBrHrjlbJFvvzQFnzQblQDDbJ +VjQVMQPVMfVPPbGPHHbGJD +pcqSttltsbDGddsCJG +TSchqLtTLFhgQbMMQMrr +trqzMRwNTtDzLPJQgWmjmjrf +lbBQdpZbsmhGmZhmmG +llVbpCplvvHBBHpnRDcDRRqnRRQnFRzT +SLSSFFmzLShsVSSHnLnrJdbnRdZZbrRw +qCfWBftpNWNNlqvTpwrRbGGCnwGmgRJGZn +NcTBNpvWvBWpMftNffpqWlTpmzPDQPSzFVMsFQVhHsjHszss +VtJtNBRBGDpdpNbC +QgLncnttvFcwwhLvFjSGsSbmmQCSDdpCmpdG +vLgjLhhrctMvLFFjLtMTLMgfPZqBZPZzJBBfWZZPRZZTRV +mJzDJJpJBvfsGMQnBM +CwPWCLRRWwRqwPqhPsrZrnrlhhQrMTrvZl +dCdLLSPRLSqWqVSLqLjgJDzDmtbngFVtJtzz +mtgWtMWrqjzQTTjghwwfczlNJdlcJnlc +FvRsDPPFGRBFvvslwDnTlcTTdwndlh +SGBZRBTsFGBRvLpvSCmgQWQjgggMrQjmmSmW +GcsRrQhrVVjhRcWlnDFGGmvntDWZ +TPbSgJJgBSCbCTbLHMCMTTZdFHvtZlWZDZFzmzZHZmmF +gBCMCSpbPMMPjcjqQQpqQprv +nZJcnZwvwzvTTTVtpDFnHH +DQPBqGGGdMdTRHRBpNgFNR +dCGPfhPWQdWWWCWShWPqrChWLLwLswjcvSJbvbLjJLbzJbJD +QrBQtdtrQBrdtFHPrdQBDvGhLGnPnCWnmpDmLpmD +NjlRJRlNzJJVbSSRVZwwJcmpWDGCWnbchnLCCmnWCG +llSJzsZzMMlsSZjSjZwJNQqtHHdBFsqdfTHhqFftQB +zdTJFHTdDBzrNdMnhNnNdM +ZlLZZcLtVtcWtGjtzLjLZjCrnVNrnRbrQQbQSRVrRnSNqS +lZtGtCvjZPCGCctPpsDDBzTHFmPmFszD +mQSMvdMQtQdZhQrPWCPqPQrN +RwjwnZGzJFTZgzggzJDDwJnCPPhNNqPrLhrGNcWcWNPqCq +ZTzDfnwFzTngTwJvfSlMtMMlmsHmHt +lZlmFRVZWmgQWhRsRpJsCJpJct +PTbPTGTGwwGrbdfjNNZJvcCsCZtvpTsh +bGdBBqGrdBPjDMzzVFZgqQzFFL +szvsmLvppPPtzGLGWpVdTSHTNgjHQRmHTgSH +FnBMBNZwZNcnDZMcnZlZgwgdQTTHjVJjHHVRQHJj +DnZrFCMZMNffrLPbLsfW +rJvmnBgnrCrGRSGNQR +hthjNfhwctwpjTLtVLjTGSpldSCGSPdlPSRzSqSz +TVcTfHNFcwtjMhTvgbHZsBbWmmZbnH +WsQgstQmvQJnssWsWPzhRzhBjZBSBRZSnj +qwCNqFwDrrlDrFPvRhTSPPzLRz +bppqwppCddlvfbDNVgmMmtMfVVmfmVWW diff --git a/day3-rucksack-reorganisation.lisp b/day3-rucksack-reorganisation.lisp new file mode 100644 index 0000000..1ab2be8 --- /dev/null +++ b/day3-rucksack-reorganisation.lisp @@ -0,0 +1,108 @@ +;; rucksack has 2 compartments +;; items have types +;; for each type there's 1 compartment where the item must go +;; elf put exactly 1 item into wrong compartment for each rucksack +;; item type is identified by letters a .. z A .. Z case sensitive +;; first half exactly is items in first compartment, second half of chars - items in second compartment + +;;; find item type that appears in both compartments for each rucksack +;; translate then item type into priority a .. z -> 1 .. 26 ; A .. Z -> 27 .. 52 +;; return sum of all priorities + +;;; ok. how to start solving that? + +(setq test-line "jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL") +;; i need to find char that appears in the first half and in the second half. +;; i could split the line in two, convert to list and use set diff function +(setq half-length (/ (length test-line) 2)) +(intersection + (coerce (subseq test-line 0 half-length) 'list) + (coerce (subseq test-line half-length) 'list)) + +;; and now char to int, +(- (char-int #\a) (- (char-int #\a) 1)) +(- (char-int #\z) (- (char-int #\a) 1)) +(- (char-int #\A) (- (char-int #\A) 27)) +(- (char-int #\Z) (- (char-int #\A) 27)) +(lower-case-p #\z) +(lower-case-p #\A) + +(defun get-char-priority (ch) + (if (lower-case-p ch) (- (char-int ch) (- (char-int #\a) 1)) + (- (char-int ch) (- (char-int #\A) 27)))) +(get-char-priority #\a) +(get-char-priority #\z) +(get-char-priority #\A) +(get-char-priority #\L) +(get-char-priority #\Z) + +(let* ((test-line "jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL") + (first-compartment (coerce (subseq test-line 0 half-length) 'list)) + (second-compartment (coerce (subseq test-line half-length) 'list)) + (the-misplaced-item-type (intersection first-compartment second-compartment))) + (get-char-priority (car the-misplaced-item-type))) ; in real life I'd need more defensiveness here, CAR woudn't be guaranteed + +(defun get-rucksack-misplaced-item-priority (rucksack-as-string) + (let* ((test-line rucksack-as-string) + (half-length (/ (length test-line) 2)) + (first-compartment (coerce (subseq test-line 0 half-length) + 'list)) + (second-compartment (coerce (subseq test-line half-length) + 'list)) + (the-misplaced-item-type (intersection first-compartment second-compartment))) + (get-char-priority (car the-misplaced-item-type))) + ; in real life I'd need more defensiveness here, CAR woudn't be guaranteed + ) + +(get-rucksack-misplaced-item-priority "jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL") +(get-rucksack-misplaced-item-priority "PmmdzqPrVvPwwTWBwg") +;; again I'm making mistakes by referring to the globally visible symbols inside of the functions. so bad. +;; maybe i'd want to use something like "make-symbol" as recommended in the part on macro? + +;; now the funciton seems to work, need to iterate over input file, call it for each line and sum +(defun count-priories-in-file (filename) + (let ((running-sum 0)) + (with-open-file (in filename) + (loop + for line = (read-line in nil nil) + while line + do (incf running-sum + (get-rucksack-misplaced-item-priority line)) + finally (return running-sum))))) +(count-priories-in-file "day3-input.txt") +(count-priories-in-file "day3-test-input.txt") + +;;; so, now different task for same input: +;; considering lines in groups of 3, what is their common char (group identification badge) +;; then map to priorities and sum +;; that should be a very similar program. +;; but how can i configure loop to give me 3 lines at a time? + +(defun get-three-rucksacks-id-badge (r1 r2 r3) + (let* ((r1 (coerce r1 'list)) + (r2 (coerce r2 'list)) + (r3 (coerce r3 'list)) + (badge-type-char (intersection (intersection r1 r2) r3))) + (get-char-priority (car badge-type-char))) + ; in real life I'd need more defensiveness here, CAR woudn't be guaranteed + ) + +(get-three-rucksacks-id-badge "vJrwpWtwJgWrhcsFMMfFFhFp" "jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL" "PmmdzqPrVvPwwTWBwg") + +(defun count-id-badges-in-file (filename) + (let ((running-sum 0)) + (with-open-file (in filename) + (loop + for line1 = (read-line in nil nil) + for line2 = (read-line in nil nil) + for line3 = (read-line in nil nil) + while line1 + do (incf running-sum + (get-three-rucksacks-id-badge line1 line2 line3)) + finally (return running-sum))))) +(count-id-badges-in-file "day3-test-input.txt") +(count-id-badges-in-file "day3-input.txt") + +;; surely there's a better way to use loop? +;; or maybe a good introduction into how to use it? +;; the documentation site doesn't give examples =C diff --git a/day3-test-input.txt b/day3-test-input.txt new file mode 100644 index 0000000..f17e726 --- /dev/null +++ b/day3-test-input.txt @@ -0,0 +1,6 @@ +vJrwpWtwJgWrhcsFMMfFFhFp +jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL +PmmdzqPrVvPwwTWBwg +wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn +ttgJtRGJQctTZtZT +CrZsJsPPZsGzwwsLwLmpwMDw