Day 3 (Puzzle 1) - Rucksack Reorganization

Successfully finished the first puzzle.

entities/elf.py

@@ -1,4 +1,4 @@
-from typing import Tuple
+from typing import Tuple, List
 
 from entities.items.item import Item
 from entities.items.food import Food
@@ -75,3 +75,14 @@ class Elf:
                 raise Exception(f"Something went terribly wrong! Other: {other} Own: {own}")
 
         return was_win, round_score + RPS.RPS_SHAPE_TO_SCORE[own]
+
+    def check_rucksack_for_compartment_duplicates(self, rucksack: Tuple[List[str], List[str]]) -> str:
+        """
+        Check a given rucksack for the duplicate item according to day 3 puzzle 1
+        :return: the duplicate item (as a character)
+        """
+        for a in rucksack[0]:
+            if a in rucksack[1]:
+                return a
+
+        raise ValueError(f"Couldn't find ANY duplicate in this rucksack: {rucksack[0]} | {rucksack[1]}")

input/day3/example_packs.lst

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

input/day3/input.lst

@@ -0,0 +1,300 @@
+DMwrszrfMzSSCpLpfCCn
+RMvhZhQqlvhMvRtbvbcPclPlncddppLTdppd
+tVMQhFtjjWmsFJsmsW
+trRtvNhfJhSzzSTFVhQQZQhHGphP
+CnLMBWLwDMgMcwwdngdHGPVTQGpTHZdGPGpd
+LLDqcDgwqCMnLWqtvzrzbbtJqPjJ
+wQQwHNQLmbWQbQRHwHNFBbwqPfjqlzRMGRqzpSfvPlzplM
+nCtGCZZtsGsrtDMZpfMpSlMlvlZq
+cJctJCgVJsCJnDTsCthGhGLwBWBbbQmLbgQLQQdWbbbQ
+ZWnNlTNTnhhQQlDNdmmpwrrrqBwjwjZd
+GzvlVRSfvMVMvGlSpdCCdjmfpmBCdsqB
+bzlFlLzJWLHHttLL
+SmzFhVDzrmSrszVDVhSVbhZcCZdfZNcnMfMbZnNN
+PTTRGqwqTqWRwLgTLTZGnCbZbNddZCCtMcNs
+sgPqPqgJgWWqjjwgwLLVFBFSVmvmBBrmJJDSvp
+CBccfSBhcSBddfgtlJmmmwmPRwmh
+FpTzzGWHWprgDtJlDZDPFR
+HbbTzWnTrnWtCbQBbQqQbSjf
+fPHspCjgwZggSvZQ
+RrNhzFZFcNzFLNLNwQlSlLnv
+TRFrcDVrrRmrhFRZzVrczqhRpjqjsssCpfHjsCdpsPfpjCMC
+ZBnBTMVTSbGbTVTGbCPgqsgPtHtgCcPtBB
+ldDrmnnNrzhdhfgcsHqcsfCcsCHg
+zFdrzNdzQNDDhFdWldDrJTbZTbLZJVVVpMVWVnLS
+pLnpQNhBbnWvbsWm
+FrFwjlTPTdTqqrDZWbvmZbpSgmJWvbgS
+RqDqRrdGFpGRFrFFdTNzCcHcHLHBzQCcNNGN
+bvRCtbtCPfSGtCcvCbPNlglqgqlGZMzTgnlZnq
+hrmWWFspsHWrzNwTnFlTMTwFFn
+HpjJDWBQmmQdRffbPtSzdJ
+GpHjFsjMFpCpMWjMGCqWmmqrWQtmthdbDbbD
+fzgLTJwJPSgJgzSzPfhmqmQhQHzQtbQDrrmq
+RNlBRwHfRJHLLfHTwLSBppNGvjNMFFCVpVFcvcFC
+SfQnfSFHfnvMtQQSnHJtMffsdTlZtdZmtllmTlmlRRbBRLDb
+hrwhWWwqzPrcCzwwzmPlRbdmlQDTPPBLDl
+CpwCzrwGzNCWrJnMvpMvfJVFvQ
+rCRPpgSggcpqrhPrCDDTLsMLDSDGLTMGVs
+HdvzmRWmlHzwvWHvRHRvHJbDFsdMssQQVGMDTMDLVLLFLT
+JBlBnnWBJlCqZRRqRBpr
+GtZllZDlfDpGHZtZBGBZpDmzQzzCSVVFHmmmsPCQWWSS
+JvFJJrwvNNcJTnbrTRNRSCzqwSsVPCPQqmCQszVm
+JLMnTbLnMgBhDFDf
+lffDhtgDJzCJNGGTzWTRRnRvBv
+qpbpdwqZwqZSwMPSqdQcQmTRnWvnBnRBQBtVnTvWmB
+SccbbwSbZbFPswpSZtgFlClLhgChhhNfJlFj
+ClmCjCJBjwBVwJGjlGNFJlVMHSrfpDpTfrHMcHTppQVrHp
+dRLZWLvWSHmTccWW
+ggtqzmRZnmhghZhZghntdqsvBbjlbNFFBPwNNJNNCBlwPGBz
+HZmsFZQpvZsWCZQvWrghGrhtgNzdHddHGh
+fWSbqWDJVwcSccNzrNhcBtGcgG
+VqVfTJnbWjqTSqbwDRfRvQvFpFLRpZsssQsCQZ
+FpFZNfplSTJmbZzddGzhDrWh
+LqLPPQjLLRMPqvjLLHQrLqrRWdzHnGhdthttGGbbDWhDDdWz
+sMLMgvRLgscrLrRQvwmTNNfpNplglplfmp
+MPVBmCmWGWRPPqRhLcnjcvjjcpjMvp
+tzwrwsJlrldJsrsrTtrzrTtSNnLJSShnjcncvnvqnSFnqN
+rswrzsbdwDHHbWZqVfWV
+dVmmMTmBPTrCBRMCqFHSWFFHWzCvCz
+jNqfGsDqtsjGjQjDlcJFFFznFtzznvtFpFFp
+fNNhgsDcfNflqchVRdgVrRPRdVTRRb
+HJPLwgLvjttmgHJFjwHgtlsBbNbbNsPpblspTllThT
+MzmcRRrdDMVTzbhNNSszhl
+mCDDVqdVcdDrqfcCnrFwtGwvngwvtWJtFjWW
+dFDpmttBlvNNgWlglNDBFttmTGHTcSSJJHHnMsJsGGSdqcJj
+zLbwMLVQbQRwVsJsSHSsHcJqbj
+wfVZLPzfZZmpMZZMBl
+PZHZMJSTBWHNWSHzVnhhfnhThhpnpC
+jFdBBtrFjpfnjfnf
+ccGrbblbGRDQMlvmQBvmBl
+PCCTsnbPbHDnlDfDNB
+rMjQltgSqtvMjScQggjfVVzBzFHzGfVGDLGBqB
+vdtrMSttcdwcpSQSdglMrtWRRPJZCpsRZJmWRRWChWPh
+pWzbsPCCPPpbptSMCJJwBQQGQt
+cDDmcTTRRqzFRddVTSJwMShMtBwhwQMDwv
+HldqVmVlZdLTcmRFdrngNNzrffjWpPLggP
+JPqvjJmmqvSLmPtpZdcftdmtfdCC
+swwhDRwBBHjFFBtBfZ
+RRzNQDwznDsDwWJjLNlrSPLSTr
+VQmdRLvDlmqZdFrBBJdW
+CMstGsnHnHGGMrMZwMpwBSbW
+GnsshssNfjtsnggnHCGhjtmfLQQczllvDRVTTQllQWlQ
+dhbNbswbwVdNtVdstBtgbNQTBCCSFTmfmMFmfRqQmmQM
+HFljLrvZfMQQQPvm
+WrpznLZZrnplpWbgdFcFsNzszgst
+LjddfTlMccnBfDQBtBQb
+ZRSNchHwhNNCHNSWPQFFFHDBBtnQDH
+CNpZshSZgpwJmpdLMlplMc
+bTmTFmqzgbBntRVsFvVwcv
+CZfMrlZLLLMlfPZRLRHGstnjGwtvGcsSVwtcSGvn
+ClZpMLCRMZMrHMLmWpqQBpzpgQzmbg
+jDmSSGWDDdWdSqqDDqCqpJzqRRqpJnRsMRcMzM
+lPgNPvPrrgNrPhNszFggnRzccbMJgz
+ZQTHQvQTZPrrQlBBrNvQZZGtTtGdsVCGsCTLLGDmLsjt
+rbCfBrbsvQqRFZRNZC
+HLSTcwqwZSQFFgRZ
+wdDwjpMHqJDTMTdqjlfBvGBhsbfhbsnb
+ZhZcHHHlhgchHhlCZZhLCCbGdrsBBGPNBjGbsjNNjnJnPn
+wtJqqwDqQQMQFqSqTzwzVTBnGdsjBdnMdPGBBsBdnrjr
+RVzJzmSVZmLLWpCc
+gdqjQQrlhhQlQrhsnjjhLgmmvmHBBmTmZRsHJzTBHRJv
+NwNnGNbGPbmTGpJzppBG
+nDnVDfMDrQqQStgM
+MLbgbppMMgLmHgQttGQJgJrBShwNShWBBSNNrwNqNN
+GnTFlzCVVwPRrVWhSw
+GnDDdvdnZDTdnGMsHbbttZgttLbc
+mdmPmjClrTzqttfm
+cpFnSbcQQsqNNtqWJzHS
+QFpcMMBcZtLpQBjVjZhlPjjVlwvw
+spVsPjTZZMpZMVLDjmdSQJCLJSmLzdJQdl
+HhRnNrqwMhNhnqnHwGNRFBNBrzSCSdQmQCdddbrQSSclSSbQ
+nFNqGRvqBfjMvTssfZ
+FjjzjnpFqqzFFqgFSZjBhHfHhnHRDDwfdTdLfD
+MmCMGCsMWbtJrtCWCbmsmWWhdLGGwRBwdfdLhdTLhHHTBd
+bJmtrRvRjgzFFvVq
+RWwWmVQGMFGmMGVCVWRRZSBgDdSdJGlSJpcBGGSlpJ
+HHhQThnjBDHfSBlS
+bPhNjbsssQzFNQqWmz
+FTDtrjqwwqGtDbGnfBlcnLcWBZwlWn
+mMhRMvJsJvJnMHCvHmhLZLQlhWQBBfPfLPBZ
+HRCCsdNdvNmCvggFStbzjbGSSjjn
+sLGddsvvcZmLvrLMGcMsVnTTlqlHCsTHHVVgVt
+wRbfJPbpNRffRJMBhpDntTCHFNVgqllFlqggHC
+DpfbPhRDJPMJppJwzfpbbDGSjrGZvdccQdjGvQZdvrLz
+wTwLNLVTqnLMsBwfMsJmCj
+JhlGvcdJhSFvFvvvMfgBpCzjzdCfsMMs
+DSlPPJSGWrDcFPhtFhWJZHQZLTQVnRWRbHbZHQQT
+TmTgTrPDNLNVlDrmlbgNmrSSGbzjZGMvjpZjvvphWMzW
+QtBfdfQcdfHtZcnZnGZzchnp
+HQHwRBGfBCGBtsrCNPDTmTlNLr
+bfNhjhNJDWhlWhlRRR
+SsscnHgnSnZnltqqfWRWrzZv
+cnfTMfmMnTnmFGsnTVLLLpQJbpbbjpdTdN
+BqwZzqRQQRRPSlFRQDDwdfWwhJphnfgfnpMdJfdM
+rcTLrcrvDDChWJhfpTgTJh
+DHGbGNVCZStGqSqS
+dlfdRNNfVdLwrRnwdwRmhLFsbsJJgLqbgCBWBCsW
+PHDppMPMHHDPzmBBCmWJqCmbJD
+HzzZHmZzQcNdRRdZwddr
+wrlshslPsSRfvrQvwbrslCDghtDgCVhDhBVJCFHddt
+mZnGpWpWzGTMqnFqDqJNDNFJVJqH
+LjpzGcjMGcTzcmmznWSRsfRPfcrbFQcfrwcv
+rWBmmmtNmmtBbtlwnhJJVZbw
+FsRcjGdLdvFslZbQJZwQps
+GHFGvMccFPjgDNbmWWBTTHNz
+GhHzmhmwlpbltGBmBmsZsBZsfCWC
+rgrcCCPdsWBgNVBD
+RnRMdQPMCqndSdQdcQhblpLLwhJbbpzGzwpS
+NNQtStFPpJwhRbRzRbqpZZ
+jLnmdJrrdDTdbgWbTbRW
+JHvnMCmDnMnMljLCDmMLjHNFGGNBPVtQQFtSNFQtPQBv
+BFbBRllFZJnPVJbV
+GpGHwgzcLhDcwttwthzzhHcPTjZjMgMVZjgZTMmTnMZWJVJm
+GccwhqcDtlrPqQrRNQ
+gWHWLgHBHQdFhjGGThTQhR
+pZsSMpZMJJSzMszzzqclpfjvrvvcRGGTcTVhbVvRbTGTRG
+lnMwsqZqsslpjlSMSsffZqqJBgHNNPNDWdLLgdDgdLHPWwCw
+qfNvBCBfBqfNMBqCZZfcnmnvtwScpwFSpSsSwt
+HzdVzLWPPGGDdnsswnztsRsnmn
+QddWVQgJPPHJTJbjBtNTTq
+DdRDDPRGGPGccfcbJwsbJWzsnznlLLWzWTLWhVVVVS
+CvCrNCqgFqvmqNZFZqqZvpWlVrlVhlhnTLShlDWnzVBD
+jvqpvpvpQNCQQCZZmmNgZfdGddRjJDPRMHcHJDHPJf
+ttdtBtPPMqWMdgPPBbVGWfTGTTzSVLfVrzCS
+ZpDpvRpZDDcmmjmZfLSrwzRnSVSnwTTR
+ZvQmjFVHJFDcQjDlZcDVHdqMNtqNBPtPJtbhhbdbts
+dGdwwLLpgwgssJpgssNhpJlnbfjnzFfcbfttGjzjlntf
+VQvDvHVVQHrQHDCZVBChrHFtzffnfltFFtncnvFtllMl
+VBShSqDVRVSTmppPwwsP
+fTFDTLNNzlcNrmDcrMDTFPwCSsbCbPPsnCPwLSPvbs
+ttQqhJtBRRGnvgHGnlSnbl
+hZBJlQBRjVRBRjhtRRMNFVmFmfDNrfWcFVmD
+mcTZFBFmqBjmBgPtCtPprmssStCP
+LWDQNqDJfQNJddnWfzhfsPRVppVVsSptftpVMS
+NDGnJDDDbzddWdNbGNQQLQbqqFBBFcjlZBlHjlZHGBTvZB
+PwDzvphPwVwWBqLLwnJWTq
+jdCGCgjmllCrmmlmjrbgmRdgJSSJJFLSSqJfLnqLLLbWffLB
+mRdjcMHgDpZhDqMZ
+cqLjhhrwZwJbBqZhMwbZZdGWdGSllWFvLFGQdnGFQG
+gHHVzzppRVggcgpcGWRQRSvdSvvGWvll
+HmNNHtVggHsHPtrhJsbjbwCrCqJc
+zqPvzLVvzFFQZzWpRLlmHRDHmRCHDH
+dNjnJGGrGdqqMprRlpqB
+GsgtjhSsSvvSFqvP
+pVrfzzjrjWVWTWjrNZvnJSJZqnnqnpSZZS
+bdQVQPRPDdcbRGPFddRVMVlZlMlBqSBBZSvSZwnwvJBS
+bFbcFbCPPCbbVHCCdVgWfrzjmWfrWrNWgHfT
+JgJqLjjjVGgdqGDZGzlGRStStT
+PHrHccmrMrTSMVStRtRR
+HWPWffNsrppfPWNsVFsmPNCJwwjdJdvdvnJwghBLJLpdLJ
+HtHvcnDSDgDcDHtpLrvwjwjfZMjffw
+CPWzdJdqVdWZpnLdwnrfdn
+GNCNmTQnPVRRglSlHsSG
+FJdhjTPbdPJjTPjTjPtSLsSBWWRcCvCvsBWztc
+MfGgrHMDDpMnZGDLCRLScCsBlgWvzB
+HnmpmNNHGZZpZZrnMPFFbNCNbFdTPVFFFN
+TJrrrJQTqJqmTltfRrgfgtgFFg
+jLRzBvBjjcnFBNwWlgBZFt
+RMjMCGpGzGznzhRmmPPDPsmMmPQmJs
+BZqwQCQZGZcVBczqBHtfbbbWfTqNWfMfPNqW
+LLpmFjpvpHrvRFSRDRMWbdbtfPWPbjtMgMtW
+SDnrpDprDFnQhZCVnhcH
+WTsBBQTfQQTTbJBbZbnfTsRFwFrjwjFlrRqvrrlqvWRV
+pGcShcGSLNJNHCLttlpllRFgpRFlRpgRrg
+GzcMLScSGJGtCbsbQfbZbMBnBn
+NGCLGjVjZjQwTGJRQdWM
+cFTcvSrFmnnpSmndMswsRMJWRwMHps
+rrrhhcTznqvzmcccvvmhgzqDgbgttlDtjjjlfVCfZCjZZV
+ccDMHddWNDnnNWMMzdHJJmSQhfQZfvQZflrZQfdVfLLZ
+bgBFRTwFtgqCgpRGFpvpVllZlhjrrlVlvj
+wtbBGPTPtRTgbCTBqFgGRwFnsWJnmDMsWMJJMzHPhDmJzP
+zsbsMtMMdnffBbzNsBtCCWLpLrCrcNLVDWVVcD
+TmPhJRvwmjmhFJwjjRPFPTvJGVCcCGBrDpccpDrCrWCVDVFZ
+QvSTvBhqwjPmwddHgtqMnllzMl
+gftDtqnpqzGZsFcthbtZ
+VlNPrBrRNrLBmdRVFCcGCZTFCsTCsbLL
+VdldlljlSNHBsSlqfgqMDDvzpHJHWg
+tQDLvFLcDrWrcnsHffCGgGHG
+ZRPTPJqhMZJZVllRZJPVZPRHnhCnfdssnCznzGhdgfwCHn
+qPqlPVlTlSqbZZVJplqlPDmrjWFtmLtFWgQvtmtFvp
+zlZzdNRPgGGzsLGCDBBtCDCtSncScP
+vWvHWbqjrFMbvrTWcVnQBBBSjLDcQJcL
+wfLHwfFqLFbhHvWhMWqwbwwRspssmzgpzGgmmNfmzmRGRz
+rPvLrQBvBLsLLdtrgssgZjwFwlnCFMtMFnlllnnb
+mNmmzpWHlzjlJMJb
+TVSVTWpqRWpSTqNbTVRBPDfLLPrSLrsfQrrvsf
+nRjpQWnQnRQzMjRdrtvvPCfmvGtPfMcCtG
+TDbrbhNZVbbbbwhDZDhbTTGfcftqcGVvmmcqcJCcCPmJ
+NLhrSwgwgnsLsQWljW
+JWqVSpGNPdNNzdZJJpMzHzwLgsMwzwQwMBgL
+clrlcvrRfccCtFbHrBWLgwLHmMHsHg
+DbfDFjcvRcvchWZVWdNpGZNqdh
+sdfvFLfmtszQwLfddRpmtDDBjVNWGMNQVQNMJGWJMj
+lccrncTZhqqcqhWggvrjMNMGrJMG
+SblShnZCqSbPhhbcbTTSZFdFsFpmdRwPwzvmswLtmm
+PGwwHpfnFSvVpWqWCQNNjCbbnW
+lmddlhcDRBlLRchdmzbNjqqWTcbNPNWTzz
+RBMrRdRhlDtPrJtfwFHpsvrHpFSrFw
+hhwlglFFSQndLRFbmCbTTz
+NczHMMqzpzPcpfBffcmTrdfGbbRbGrdGrLCL
+qNzNPqMjcqNBWWccBHsZPDhJnllwnwvJvQnJhQsgvD
+mbmvmvbbprZmlFmZbFgLffgQtFNHNhfqQtNQ
+SJcdzjSJBzdBdJDzQhhLQfqzNQQHggRL
+jwDwcTTDThvTZPPW
+FSVBBBvHvCpVVDDGcGwNNhhctwMvMc
+fLLZsZVQmjfTfqQRmQhhtgbbJbGJRghtcGct
+qTsTQdqjVfqdVdZZqVLpCpzSpdppBlSpCFdHSC
+sQQhWsMmQshlhmMQZFDHDJFjgjzHZgcHdH
+LnwnpNRrnrbCqqLpwnqfnLcvFHJFzNcHzJcgJJHgdDgN
+wCbnpCfPCVqwwnrrbbPRGMMlSllmlTTmsThVMlsd
+pzrprfwgbwtwqzrCWbqCwqSMvddHdDSvtHRlDnRRDddD
+zQLzQQjPBPFcLcQFTFsmNQzcMNdDdvnldHHvdvnDnRnlvRnJ
+cTZGzzscLcPrqrfrZqqbVV
+DcSdcTwDLmcwDwvWssGfJfcJQZPGnfcs
+FlHFMgtgNggpsztMHMqpjgBBnCfPflfQnZCQBBCnRPZC
+gpVjqNVrHFtjqqzSLDTSmTDwwrmhbs
+MLMzJTsZzZMgMLgHMmVmdCVhCBlQwDwwhChD
+vtPRQpbqCldwdtBC
+bQqFbnQbcFfjPRFPQnTrMMgcJgJrssrzgrgS
+mtdGJmQRFmdtQvdvtRtdHzHzqZqpHFzZnCzhZjjH
+fPwVlllswMVNPfBDDlNVsMsfcBjchHncqzjZbpzjcqCnpHHn
+rlsNPWNlhWTPMMNPfwNWTLQRvQLLmgvSJvRJgTRG
+TwnqhqqgvQnGBGmBDp
+SMjclJSjjVJgCzCzNgpmdBpmBGspRBmpDDVB
+JjMCgMMHMMZNStllZSNHhPqFhFWfqPPqTqhLFqtL
+lRQPtjPRlDdStDSlPmvllvLsCphFfCHLHggspgFmsFLH
+qwpTNprcbNWVHLrfFssBgFCM
+NTWTnzTTWGZZZVRSRRQGpdDtSQRp
+gpwTPNPBPTdLLLLVGl
+jSHdjzZHMcDVtDvFjtCF
+HqfZMHzbcqRRRWgdqPmBBBNmwW
+PvSBtdFgvSmBPngFBTBjbSjwwpGjsppMjNpMjj
+VZLfVQLzQQQhllpcNcwbssvwwwZj
+vHWLVVqWTmTgttgq
+CNRmNRFNRCWbWNCrlmfGlWqFLsDZQZBZzgwQZsBsDZZCzczB
+MSjdVHvHnDDhHvdwBwssZVzwcgLcQg
+HnMMTdttHSHSpHvDddpSHTjWlNWFlmRtRmRbqGfqGGNNfR
+fBLTDppznrfTndfnfTzTLPvZvvHVbRbggjvzVbzvbV
+mwmDGGlqDhMqthGqhJMWmlNVRZPHjgwjjRZbbHRgRHvv
+DmhsJsshWGhSGlmlmrdcLLsTBBfcfnBppc
+mbCGFFmGmcdTrCTQdh
+MJHfJNLllJffPLRTdBqTRQNcqQGB
+fPJHfSSSWfSLDMLWGHDMLDFmznmsjmvZwzvjZjbvbZ
+pPvpJSfZTTvCzNZczzQZchcj
+svbHWsqsvbsMFtVHgVtcRQcDlQRRRQLjlqjczj
+tBsgvHVMFggbgFrgWnwSndfBmmBJfPSfpn
+jwbwfjSbwjVSjvZPzWSvhvhQlCsBFgLRLLgBLRClLLFQQw
+GdNJHpmHTDnTNJqnFCgBLFLFzFtsQRCd
+NpMJHpnMrDpJGTHqTTmJHTPjfcvbWfrffVzvZfVWSbjz
+wFwpqWwwpqwtqqrbCFtptDmCcfNhNRzRBZRRJRChVNBZBJ
+svlvjHsQlvdlvMLdlvPSSLtzzczcNhJthfNtRcNMJNMc
+HvvPLSHjgltjsvqwbbnmWmDpgwTT
+zhCmPVwwChdCBtsWnNWswBWr
+GJJSfSgFpjJjGgpfpgrcNNstvnBHNnHLtFHr
+jgDTfjpMgZMGMGJTMMJRhzZPCzbhVlPqdNCbhd
+bDbQQmVDRpDNbRQlfQQZnfwTlllfsT
+FChzzBWhVzrgMwffJwlnngnTlJ
+MCvqvhFzcHCChjtpNNVLppGmbq
+bZZzJnccqdzcLhrcQDLrDs
+FfCfWVfjWTFClClfwjWCfGGwhZSDhSLsSSRpZprLph
+mFmTMmFjMMWFfZtttflWjmWTngNHJHggJJHtzgnJvBtBgHdv

main.py

@@ -1,21 +1,17 @@
+from rucksack.file.rucksack_loader import RucksackLoader
+from rucksack.ItemPriorities import item_priority
 from entities.elf import Elf
-from rockpaperscissor.file.guide_list import RockPaperScissorGuide
+
 
 if __name__ == "__main__":
-    my_elf = Elf()
+    rs = RucksackLoader("./input/day3/input.lst").parse_file()
-    other_elf = Elf()
+    i = item_priority
-    rounds = RockPaperScissorGuide("./input/day2/input.lst").parse_file()
+    duplicate_prios = []
-    scores = []
+    for rucksack in rs:
-    for other, own in rounds:
+        elf = Elf()
-        result, score = my_elf.evaluate_RPS_round(other, own)
+        duplicate = elf.check_rucksack_for_compartment_duplicates(rucksack)
-        scores.append(score)
+        duplicate_prios.append(item_priority[duplicate])
-        if result:
+        print(f"{elf} found duplicate \"{duplicate}\" with priority {item_priority[duplicate]}!")
-            r = "won"
-        else:
-            r = "lost"
-        print(f"Elf {my_elf} played {own} against {other} and {r} with {score} points!")
 
     print()
-    print(f"I've got a total of {sum(scores)} points!")
+    print(f"The priority sum is {sum(duplicate_prios)}")
-
-

main_day2.py

@@ -0,0 +1,21 @@
+from entities.elf import Elf
+from rockpaperscissor.file.guide_list import RockPaperScissorGuide
+
+if __name__ == "__main__":
+    my_elf = Elf()
+    other_elf = Elf()
+    rounds = RockPaperScissorGuide("./input/day2/input.lst").parse_file()
+    scores = []
+    for other, own in rounds:
+        result, score = my_elf.evaluate_RPS_round(other, own)
+        scores.append(score)
+        if result:
+            r = "won"
+        else:
+            r = "lost"
+        print(f"Elf {my_elf} played {own} against {other} and {r} with {score} points!")
+
+    print()
+    print(f"I've got a total of {sum(scores)} points!")
+
+

rucksack/ItemPriorities.py

@@ -0,0 +1,3 @@
+alphabet = "abcdefghijklmnopqrstuvwxyz"
+
+item_priority = dict(zip(alphabet+alphabet.upper(), range(1, len(alphabet)+27+1)))

rucksack/file/rucksack_loader.py

@@ -0,0 +1,21 @@
+from typing import List, Tuple
+
+
+class RucksackLoader:
+
+    def __init__(self, path: str):
+        self.path = path
+
+    def parse_file(self) -> List[Tuple[List[str], List[str]]]:
+        rucksacks = []
+        with open(self.path, "r") as file:
+            for line in file:
+                line = line.strip()
+                if len(line) == 0:
+                    continue
+                comp_1 = list(line[:len(line)//2])
+                comp_2 = list(line[len(line)//2:])
+                rucksacks.append((comp_1, comp_2))
+
+        return rucksacks
+