add day 4

2022/src/day3/input.txt

@@ -0,0 +1,300 @@
+mmbclcsDHCflDDlCrzzrDWjPJvjPvqJPjfpqZQdfWd
+NNFLnFRNhgNQtMLSFSgwSwGJPZWLPvjpjjJGZJPvWPvJ
+BnwFNgVVhwNwVQrmzbrrCHVTmDsm
+CTsVssjPTWPbzhfbfqqpbqJq
+RRttdQlRdnNpdmwBnBDhFrGrqDGBqJJfJD
+HttgcggdNwQtgcpTsvjVPTcssjsv
+bWrpnrpPcFNbfPtwVPddVVDw
+jLgqqJgjZLhHjRqLHLjqHgftpmJVtTmwQmtGddwwDVJm
+HhzgshZLpHLjqhLLZRZpLRbbrlBNsrrNsFWcCvvFCcNN
+PCJJfJhjhzjjdBVBcd
+RnNnMHnRNtWnBSQHVbqSzFcq
+ZlnZZZNmLrNrgZmmccGJwGwmGPJs
+hFZLsjjjMzwPPjqw
+SQtTcpWWcpMSDlQpDCQJqbHzdSzPzJvPPwqqvH
+tVfpGWGDVlCGGDCpVWppVcrZFMrnmnLfsrBrnngLmMBh
+PFPhCmpfhSMWnmgrtgMW
+RRQdGQvTQRzQDGQTQcRqTTQLvsntnltvrWZlsWlZftntrMtt
+NQTzfGfzcdTBhPJSNJbCCVhJ
+sbtqfrqNfcdqsJrfhzQmzhpvzvpQmpNG
+SHsSDsZVHBHnRZDBZRWSVDnwFhzvphggwGhQzQhgwzmmPzmg
+jjHVHBlHljMsJjbbCcdttc
+NccBbvbNZbbvBGPVTGhhlCZCPg
+tdWHQtLLMrrdWQRqWrMrMrMPsTPThDlTssFFCFCVTDtCDC
+zzWmMQQLVQrWrbBczNnwNbnpnN
+THGhBHgHThvnHRrQRpMNSwZSMrwD
+szsCzWljNfVFFVllPPzzVWJMJZQMJbpSrwQCCJMDZbbb
+WzlfFlflfcmfsFPVfWVVhnNgchHndHgdTnqdNHTh
+zPhDwsWgszftMNfPjjLL
+RTRbbJFHSrqRRrHRrjGQBnfjQQMjLnmNnF
+ddpNSNNpSdWsvpllWzsl
+FgDgbSMnhhntCLCC
+HlqzJgPfJJgmrthhrtTLqL
+fjfQgJPGVjwGJcFMcSvdScWjMD
+pnFwRPlVVlLSwpGbvSmZHmbbdbHm
+sCzTQtzrrQMzpthTdvbGHdvdHNsZqqqZ
+ChTTWhWBWCDrrTrjCrhtLwwLFgfLFgjnpfpwLnVg
+MRDfBDMJsQdmGWsM
+pFPqwswhGzWSCwGN
+jphpbgbqgFnqjjnthLtJsZfJRHfllfTllDLflJ
+sdbLCqnbllplrdrsqbZHRPRBcBcBZBcHcZrM
+JJFwDDQmzfmhmWhJhwFWbMbcNBNRBBzbNPHcMHPj
+DFWVQVGGGbpGClllqLSl
+mRmFhZRsmFJfFRzwRrFrqmRFtNLLDTPccVqVtGTLDnPccPDN
+SBddBlZMjpQvvBbZvVDTtDTDDVGnLTMPVT
+dCHWlbHbdbllsRCCgFwrrZCJ
+hwvwFHhlTLwpLDQhpHwTwBLSfvzSZZsvVsqCGqzZSfCvVG
+WNdtmjPjcWdWJWntcWbjzmFzrrVrzsGzsVsSVrZZ
+PbJPntMRbbdJbcNPcNFjnhlwwgpDHRBpggTlQThhpQ
+mJvRGHfWmvWJJVmZZnZVffpglGggrTLNzLwNLrszzNpz
+FqFMMShqjcMcqPbbjPthNgRggPgLwPsgLgszwNpl
+DFQqQMhRhDRmWndDnJvmWW
+jVzfvzSVpnnNSGjjVpNlSNDzqBBmWCBtWWtfFFCCmPmJCCJW
+HLrRLhwrMZbHrWqWBhGPCGBFJW
+wHHMRMQRQrcQRTTcHrwwRcQbDnpvnppzGSnvnSNzDSNTpjnS
+qzrgfppGzPDJHfbZbHZn
+vTsMvMTclhNlFlFhdhdqHHmHJSJDVJnJFFwJHHDn
+slccWTTTcdCcCqRQPrzgBWPPRz
+thfHHdDwbnVzwwdthZlqjZmmTmjfZcfMQl
+sGFGJFFvGpFPCJvLPGPgZlpmlTMcmlmZrmMjcr
+sJGLSWRSPBBCCPRFWPsNBNwMNNVMNwBzzMDhnh
+RwJMwdbzMGWbLtLVQpPl
+gqNfBmBjNmcCqjqjQllWhhQlgDQtpWlh
+cfccjmcNmHrHBmCBcTMGtTJtZzrTvddRGR
+vbbvqMhcrqMQQLHHvFvHHvpPlnPLfVfPnfmwsNwwwlnVls
+ZdBZZgDRDzBRJWBzzDZjDDNWNnNnPfwNPwmSwlnCnfCW
+JgRggTDtZmmbbFqrvT
+lSgzfSzgGcNfDPsbMpspbPnnrrVV
+FmWFBFQHBJJBmmWJFHWFrwtsVrMbnrVVwwwpWMMp
+FFmmJmvZjQBRQRRQZQBvNNglRhDNDffDSDSMGlDD
+VQPBCZVfHQZGRVVpmzPFmgSgbSPTFb
+NcwLjcWnFhCpLvCF
+tNCDtsqltDwtWdncJZVJVRMGdBQffHZH
+pTzgPsLQfMLqTVFLGbVbbFVJVF
+ZnjgjvSwNNbFJVwN
+jWcCnWHWRvWRHHnWRWjvdZnZtspMqfzrMqfQtTPQgfPzfzcM
+CTqHMNSSVnpjNSTFzMwPdslwnlPccbblgcbd
+WDLqvLQRfLBgbJPwlWgdPd
+QRBqqDmZZRBGGfCTpCCSMSmzjSpz
+bPlRhmnPhTwhrvrlRrjgLjgsLpszFldgFlgF
+tGHWfcQHWfLZnsLQnjpn
+cVGtCtGGcNWcWtBStqnWrwmvmbmJwJPwbRBhRRMb
+BjVTVfBsLlLjLcBcZDRJpnJRDPRJqlPRqJ
+SzbQMQzFgfFzmMSrbzGpqqRDtqmnvDHtvppHDm
+CrSQSdgrWdbFQCWggjWZTfBWcwBcTVBjTs
+RtqdCqCTbRfRbbHR
+FhwWWqgGJJgJHLHPFFsDbsFP
+MrpmmwqhMmJMwpvlNvtlTrvtZSSr
+VscvcmcmbhDrRMCCJlqnSlJnSljR
+FWdwWgpZgdBLTgTWFwZBgWpjbCNqPptCSlNCStnSJJNPPJ
+FdFWGgWTQGGbGvvDHDHzMD
+WhhBJrBqBchcQBBqcqqGRZRlrtStlSlRszlzSSRl
+fHdwgdjbNCbCCHNgPgHNPNplSRtQtltlRDZsQfZsZMRQMR
+jQbQNwVNvWFJvqcV
+bjbmmgSjwTWqWwWqcw
+sQGfPZQDPqMMWWWd
+fqBDfqqZZGHGDsNLjtmlttpgBllpJt
+ZDmCWtftfWBLfRDWwbhqcNNtqwjtjwqt
+SnTTsnlPMTlSSsGMMSddSbHjhwJwwjPbcvHwLwcqjj
+GrFGzSgnTzLgDVfQfQrrDDfm
+PngprCCmcBDssRFBSbFRRs
+fjwHtjfNWfGwHfdtjGMdWSSdQTsQRLFSSslPSFTRlS
+jGjMwMffWHNZfhwnDzqCpZDgrqCcPr
+qzGPbzbDZGSPvpvrTvQsQwLWWNLj
+tFddBhgnVnMMhBhLJWLwjQMwMrMLwT
+BHFtVHgtmlhRRZmSTDTpSq
+ZwzLWWWvWdSJdJQwQLzBqqbbhhCcNzchqCNPhb
+rHfDRfHGfHsGTPPmhmrrNhjmNg
+GlfsfRTfsfRtsstfDVHpGsPSFQJSWQMJwdSLwQWpZZLd
+vnvJvpJtQwDBTljHlLHhDL
+zzGqMwqMqbfRfVGzFmLmLTLddjmTSRLBBB
+zGfrbqzwNvPPcCtr
+jwCwSgvPSmCwSqwgbCRQGvsRVnddGZdflsfB
+MhzHLWpMWHHzNzMccDHdnZVZRZRGQnGlGRGLsZ
+nccNHTzWHDcMWHcphpptDrcDJmSgFTPjgPFjTjgSbqJSJqbg
+bVhPWqBBbdbdPqVVqhSfpcmFsfwLnmmjnfBFmn
+TDWDGzgRvrNJJJrzzzGspwpjncsncFmwFmsNfw
+vMDgDJRWgDJtHDJMMPQQMdQlqdlhZZQbbC
+SpdpQqLwrDcmPhggcS
+ZHCZstHMhjGmtPDc
+NNnnRHMZNzTMHZZTTsZMvvRhJJwWzBVLVQJJqWwVhwJpdJ
+mrlMQlQPPPhhCbZRNpRZcffmFmgc
+VvJVJqDqvqjDqvtVttVSHTTHLLcggBNBBSRRFfRLncfFLpBB
+jHVHvdDHtJjtDWjwMhWwhwwwlNswPr
+MJvzvFLhbTnJCvRwWSTmSWWWmRpc
+tlVlNqBsVNNBQPrWgqmcgfwpcWpdcg
+ZBjHPsttQrPrrVsBQpVJzhZhvnnbMMLvFJJZMJ
+hBfJffJJNhnDlmQdnmSGcd
+sQrCpRsPCrwFZQprpQCzljdjMMjMGGdGSmgSFFDS
+zZpzQpwzHRPPTrQwCpRzWZHqLVvtBJvbBtVJhJLhHtLbVv
+DsPnQGnnwlVJbSsb
+HCfCfTDMTfHvCWMZDcRVVSwpbtlhVZbhhpVllp
+TmCMTvfjRCCvcrgNNPQDmNzrLF
+ghwNtnMMRTZtwTphjjBQfLJjfJFdSBTL
+lldzbqzrCrfLJJBBbSWj
+DCvlvqvshNhRndGs
+rWwWWDJWWrFLdRWtRhFZTCbCSqThFTCbmm
+BgMvSzvMpVpBlQNQVgfqhhGCbGbThQZTcbZTCs
+nMpfjVMnzlgRSrnHnwdSDH
+blFhFgFgPLvjDwNvWPnD
+qMBzMCCzZMzJHRrzMFZsnFjQdZnvvNvvWQ
+FzpMpGMRrlSSghLhtG
+hDlVfDdSTjTJwjMTZT
+HgnqtGgQRgRHGtrgqgSZJCrwBZZCrZwWJWjMWZ
+zqRbGNSbbGRRQGRQFzddfVDLVhhfhddV
+JwhLdLNLbwmJggCbbbhjHnDQNZWQWQjWZZPlHQ
+GStzfBFzBMGMftpGcFFQDDjDQfZPfnnmDPfZZj
+FqMBtFstpcTMBMSBGSBtqMhrwJLLTCbLhJbrhTCmrChv
+WwWnTNVBNvWwBngdSqdRJJzncLSLpc
+HPMZlGZQGtQjPdpqScpdjP
+GltlGDDCMMplHCDphtbCHDwmWNBgVgvWhrmWssTBwWWV
+clNNclslcLVWBNlGcVvdSHQvTMHZZSdsdQHM
+gGhfpRwRZHMdJgZJ
+fnDrpDtDrrWGcWVW
+zdVzgdPSWRsHVzPsRRPHRHRRntnQrbDmfDfwfQwwZwfnbgMD
+qNCJvjNLqjNhBBGjBvchhBCqffbffDGMnbwtfnbmQwQnZQMt
+jccqJBvCjqvLTLJhJZpsPdSVdPszPRFssT
+lDLvltDpvSpqGjVVMljGjW
+zrdnswzcSzCgrdnBBjVcBBcjWTVTGb
+PZgFdgHHnrdNDPvvtfNQSJ
+GlLFbFNFtzcvddVpJVfGsCCC
+PWhhMgWTTnhQrqMHTWqwddCVjSwQJddpBdQffp
+WqJZDHPWgJrHnPqhnnqLbzzcLmbFDNmcbRzbbN
+vtDcSfcWfmfTSGwvGDwTvFZVppsszCsVVVFjVzSVSM
+NrrLPhdBRJLbPhrrRJwhBFZsFVzQzszsZzMCZjsJQF
+glgwPqPhrRqPqBdNLwBrLRtnGHnDGmDqHWfGWfGcncHH
+BtSfgpgvQhlSlwzZ
+VHRmVzMPdPVRmcdhQwQwhClNNNCb
+PcPMRWrVRRHTMDRVLPVzBnnJprjppBJtJftvpBfp
+RpgBRVpLgBpDFCCPPVGvPSVVvb
+dHrMdlWwwljjrlHrqmWjmWlGNvNSBBNhhSCSbSvNtNvQGd
+TfmjqrwqHmqHrqlHwHpgfZFBzJgpZnpDcDBZ
+NWTdFWlSMMMWTzVzdQfVpVDwwf
+RHrrGrLqJLBqgpDgQfwfffHz
+cssRRsBjvrGRjLBLrZcBvBqWPQNnlWTmSnjFllWMnCTFll
+DCCDbHDhgbtCLHFHCQdQdSVfbNMdnfcSMS
+ZZjPsqRZJlJlGZPTTqqRwJjZQVnMszVfzdSVScQQSQcNQNfM
+mlGJJqmZjBZPhLBrgrWHFnDL
+wLpCpDmmLwplgwVLwLwVgLLbWWJvJRTsRvbbJWCRsfbssv
+FHHPFZnnhZQrqTTlSJRSrlfvrv
+llZlPQFcZZHchjhjPqnjNFqNwggmDDwVNBBDwtpGMVDwDwVp
+CctttjCrftNrBZpPgpgbNqdq
+JhMwhMTGhMVhwDDMJJHGJJJBldWggWglddlbqlbPHbfqgf
+DvJRMJVVJMTfJtnrnRjCSRFnrL
+snDPGSQPnSSQQFwFFdzWFvmCVmmnjmCJjHjbZZhHZp
+clgrgrMrRfqRlNggmhmHrhvVbpCjCVvV
+fNgcBgqqLMqRqgLggtcTftBFdDFWQzDSQWPPGwWpwtGGsP
+wSJWDCbwVdQfbffHfZZr
+glgTBzzPSFhLFRvRQnZspZQpnvRp
+qTLqglLNFqBqVMJqwwMVcS
+rCWNCsrGrGGHrwQQHrfNDfvgLmmvMmLLMpmLvLPpPgww
+djcdVdqJJcqqBstdBczbStThPPMPghvSpRgmlvghlmLpLp
+qtjdBqzbTTtzTJTzVnbBdsNfDHZGGGDDnGfNDHDHFZFD
+mlzzVHZmzvHflTJHqlJcZTvdcdCCPnddFGhPdBGhMFGCGc
+QDRrWSprdqqCqDhF
+NWtQNRrgWjpLjLsrRrQpfwVVqvwHzvvmVszlvlvm
+DmDDtBDStSLcjLBDhhhmfnNFNlJJMFWFHSMWFpJNHp
+PgMCgVgsCvVwRVRCwvgTzCMRWWwdnWHpNHFwWJJnHdHpprnp
+RgZvvMbsbPCRGRTVPGmfBqDDqmthDQcmcZDc
+WrfWpwwCwpdWCMBzqbtpjVbqzVqp
+RvQQSFJNFZNNLPGbMMPqGtGPzF
+DRvmNhZvJZmNmLcDZQcQNRfnnTMwrMHnfTrTCslsclCn
+httbcnSsgtVMsnssnzghmmHvNmlHVLBHBLrVGGLN
+QFpjZqpqWddZjjDWPWPwjFpfGLBfBBrrNLlBBgGrLCLmrfBB
+QRjRjwjwDhbRTJnhgR
+FTBTZqFVJnVTTPBTVmFbNjRffzrRrNQrPNQbzh
+tCWwHMLCLDstlzdjwbzbQhRl
+GvtChDChvtGSnZqnTVvBVF
+spnFVspFPScprWrGvTpTWpvW
+CgMqCqPLfqBBJGHlMrrJrWWl
+ChjqhCtgdLPSQhQsRnVQ
+bCQVZCJcrSSStrWTdhQqhzzMdhMz
+lPDwNfgpDfBNgfnlDPRDpLWRhLbMjzWqMqWsMLLhLz
+wpNPgPwwBDfvBnfgBfwglHDCJmtFGFmGSmCVrVCGbrCcFv
+zNMJCHVJQmNLQFhZ
+PPRPdGcRdPPjfjflqdjPDPTZQrhTFZFrmQZQBGZCFmLL
+CcWfjjgWtjtMJWzVnSJVzJ
+LjhDjVCVsjNfMsMQ
+SdRpGSndZnlgpdSFtrQMtqNZJtwrMfQQ
+cdRpcpnggRSmWpcLDHCCHfhBmPHTCV
+zpmsJlptmfNwwFswGHThRcTqqHqhhWCWzh
+SLgLMMgnPbSLPbPMDqZZcTWCnZWtRcWCZC
+MbbvQtMVSLVrDMvSMSvSlwNsFNJspJFfNNmJrGGf
+wvcQjfjQvQDJvwNwRdpRScCHbpdMbSpl
+rfrZzrzWWmzlRpMMdpzd
+LqrmFrVhFJjNfFfw
+fVflVfmjQtZhzdrdlN
+HwLLJvCcpcbRvDwpDvDCpqtTPPMNWTzTrHZTMPzPMPdH
+LbvbJqgcqbpJLwvbbbmsmgVGmQmnjdSfSVjV
+FngtfmfTTSFjFDnfjDbwnGzzGBGzbVRwVcwz
+WWMrLLZLvZMWsrCcjzBGcpzLcGcVcB
+NhMWllrsNZNrWZWhjCmmSmfgSTFDHTJfFSNq
+lpqpqlhTSZqfZlwthPHsHcdHPhsCHLrP
+zVDTjMgFbscczPbz
+jRRmvmngNngqTZBqNlftTJ
+wrMrJZPPrNZPZzhzMFPlDqSllsLSbWDWlWqNbb
+VpGftgghtgQfVBgdnpBBngtWDSRbbSqltbRblDDDtqSlqS
+gVggVgpVHTpmndffdVQVTVggjMwwjjMCjJFhPvZMwHvzMzjC
+CtQPCFVlljWrNhTmCgLL
+zsZbsnsqbMznDGNrrTqTLqWRHghN
+zsMMGMSssSSzMGGMcvDGJFphFwPPvPvQfJppwQfj
+njfVlRDDfDwHSfwVwSLnQZqGBbGsnZBnbGqZMbbpGG
+zvddNNdWFgTPFgWNvNgcZqZbbqMMgBpsZrRZpgGG
+CPchdcRTcNvvTWcmTNDSSfjwSDHCfQwlJLHl
+LPmccvvFzzLvvQSzlFvFSSQDDtDfdDVdnDTBDsVTjDndlV
+CbgNZWgZrbbqhrgTnVjjCsGdBfCfTs
+BhwRrNrpQvLzvJSw
+DpGFVsprFpTBJjsnJnnhdjWh
+fbHCcbVHCgfMLwcqfLwgNdqhjRhnJQQdtQWnnSSJJj
+gCZNVNzbHbfNHcHNgfCMLHHzPBDPvPDrlvDrDlvpmFTFBF
+tsBQFgFpFBfsmtLjtgmtrQvCddSwSCwwbRvbwdLvwvRG
+nqPZnMznTZHZlZPfGCHfbHwNVwdRwC
+MPWqqzhZmBWFQfFW
+FNMTTwqwNpVWPgZFFQ
+crScdztJtcccSzWtzzzbStZQRZVVVHZVRgRQPHQhhjSZ
+lCDCCdJJdbCdbcJzrcnrJWbnLLlvMMTLNwwMvfvwvMmNBNMG
+WHsJMlBHCscDPDPtPBRDrL
+jmTvgnqdsbPmSrrPVrwL
+pdTgjgqbTqQFdjjQdqTZzCcJsZzQzcfsCCHMMl
+QqMQGbMGGGzSsQSqCPcCPrCRNNlSZllc
+vDHdmDWTdmwphhDdJwWvHdDCZPZVllPVRPRZNPVcZbTBZN
+pmWHDmpmLgJvhvLpmvdvLWbsMgfsQGjqjtsnGfGqzGzzzQ
+tFvMtFtFMvDDtMvLTpffQWWSGTsDTlSS
+jqVnBjHqhPHbnhqPqWllfpfSTplQPQPGff
+bbjHVHdjzqBznqVHBHzzqVFMJNMvmJtvtmcQFMZQFdJL
+dcldCJQnldtTMdsccThhDDDDFhwTqDRwHR
+ZbGzmgZSBpPPmmbNbZmgmNPPRqFzzVVhrwVHwRVHrVRHRRrR
+bSSNmhPGWWZgQtLWtlCdJCMd
+ttGBGNNgBgVBltlTJGJZpZlHSHCHfDSWpRWWpS
+LhcLrcFFqdhLFLqvwMdhcPWpHHSSZWjjjCDwSSSfpWpD
+fPMrqMMnqMFMbqcfnPMMBsgNttgggBmzJzbmGtbb
+fjFhHHHmfjtLjrFmPhLbCdzBCpPCJQpJJGzJCp
+RcDTnvlVqRnvnvRNcSzCJGJGCSJJCCdQqw
+NTlMZVVlVVVlRTDTNjgGLfhrmgLFfZFGhr
+GmbVGWttmpmbbqDWgVGGGtWNvNCCsHLLFsvHMHHLFnFn
+wQQSdDTfSTsLCNnFwvFv
+dPDBTBjzDftcBqBVbGBg
+LmsfRLwCfZslcjljcjDjwN
+gdRSrHHrSbdrggBzHBShHlqVvVDvcNvlcccjGlGjqB
+zgTnSFFJdngddTZTPTWmspWQWWPR
+RMZMtdsVCsRdddbsVcfcqgNfNDqGqGfzPzmf
+BpwQrJvrjnSnQpBBBJCJjBBQlzvmDPzmDmglPzPgDNfNmNgz
+LjLTnSpwjQTrnnLCBJLQjhstbMhsRtTdtMHMtbtsZd
+PfrPHmrCRmRhcHCcmCfhhmWMLVpwVqFvvGGLVpQSwwSvSFFP
+sJnjsgsDDdjjjdTglTgDBsBnSLdvwSqpQQbwQSLLLFSpQpbL
+tBlngnqgqZggTZWfCRZmMCHHmM
+LGGPQLDLPWmQLVdVdLLGbdvMNjfvHNFNNBbZnNMlHlBf
+CshzsJBqTTwhttzCJzRtcNcMljnnnMjHlFnMcvnHfM
+gqJsCwzBrQWDSgGmSS
+FWVzVJjmbbJVpPwjjJDQsQNDgtcrWtddDQMg
+TqRqCfGGBTzgTzDNNs
+qRffnhhGvvvpwbvFzp
+gLmMTpTCmRhgTLhCCZBSScJFQQQclWWMQJSJQW
+rvfbDGjGssqbbrRSJJWclqcSwzwScc
+PsDfGfVRjfTTTZNBPTZT
+hWqrPzzMhrfmfdNtdZLNrnGndn
+SwvwSFslbbjRsspQwsRwzcnbnNdTnZDbGctZdTNtNt
+wvJJFsvpSSvJFjlHjzplQwJhCfVVhmBmVWhHWmWVWqBqMW
+GjQtgjhPhGgsQjgtthrrvBlvljCrpCdlqBMb
+RFDHDRFRczzlbqlbvqvHdb
+DDFcRWTWFbSwRWbGtSGtgPfGGSPPtg

2022/src/day3/solution.py

@@ -0,0 +1,60 @@
+import string
+
+
+def parse_input(lines: list[str]) -> list[str]:
+    outputs = []
+    for line in lines:
+        stripped = line.strip()
+        if stripped.isalpha():
+            outputs.append(stripped)
+    return outputs
+
+
+def find_duplicate(rucksack: str) -> str:
+    first_half = rucksack[: len(rucksack) // 2]
+    second_half = rucksack[len(rucksack) // 2 :]
+    for item in first_half:
+        if item in second_half:
+            return item
+    raise RuntimeError(f"No element in {first_half} present in {second_half}!")
+
+
+def get_item_priority(item: str) -> int:
+    priorities = {
+        letter: priority
+        for priority, letter in enumerate(string.ascii_letters, start=1)
+    }
+    return priorities[item]
+
+
+def part1(lines: list[str]) -> int:
+    rucksacks = parse_input(lines)
+    duplicates = [find_duplicate(rucksack) for rucksack in rucksacks]
+    return sum(get_item_priority(duplicate) for duplicate in duplicates)
+
+
+def find_common_item(rucksacks: list[str]) -> str:
+    if len(rucksacks) <= 1:
+        raise RuntimeError(f"Cannot find common item in {rucksacks}!")
+    first = rucksacks[0]
+    remaining = rucksacks[1:]
+    for item in first:
+        if all(item in rucksack for rucksack in remaining):
+            return item
+    raise RuntimeError(f"No common item found in {rucksacks}")
+
+
+def part2(lines: list[str]) -> int:
+    rucksacks = iter(parse_input(lines))
+    duplicates = [
+        find_common_item([rucksack, next(rucksacks), next(rucksacks)])
+        for rucksack in rucksacks
+    ]
+    return sum(get_item_priority(duplicate) for duplicate in duplicates)
+
+
+if __name__ == "__main__":
+    with open("./input.txt") as file:
+        contents = file.readlines()
+    print(f"Solution to Part 1: {part1(contents)}")
+    print(f"Solution to Part 2: {part2(contents)}")

2022/src/day4/example.txt

@@ -0,0 +1,6 @@
+2-4,6-8
+2-3,4-5
+5-7,7-9
+2-8,3-7
+6-6,4-6
+2-6,4-8

2022/src/day4/solution.py

@@ -0,0 +1,46 @@
+def get_sections_boundaries(sections: str) -> tuple[int, int]:
+    split = sections.split("-")
+    return int(split[0]), int(split[1])
+
+
+def parse_input(lines: list[str]) -> list[tuple[tuple[int, int], tuple[int, int]]]:
+    output = []
+    for line in lines:
+        stripped = line.strip()
+        if not stripped.isspace():
+            split = stripped.split(",")
+            output.append(
+                (get_sections_boundaries(split[0]), get_sections_boundaries(split[1]))
+            )
+    return output
+
+
+def contained(sections1: tuple[int, int], sections2: tuple[int, int]) -> bool:
+    section1_contains_section2 = (
+        sections1[0] <= sections2[0] and sections1[1] >= sections2[1]
+    )
+    section2_contains_section1 = (
+        sections2[0] <= sections1[0] and sections2[1] >= sections1[1]
+    )
+    return section1_contains_section2 or section2_contains_section1
+
+
+def overlaps(sections1: tuple[int, int], sections2: tuple[int, int]) -> bool:
+    sections1_overlaps_section2 = sections2[0] <= sections1[1] <= sections2[1]
+    sections2_overlaps_section1 = sections1[0] <= sections2[1] <= sections1[1]
+    return sections1_overlaps_section2 or sections2_overlaps_section1
+
+
+def part1(lines: list[str]) -> int:
+    return sum(contained(*sections) for sections in parse_input(lines))
+
+
+def part2(lines: list[str]) -> int:
+    return sum(overlaps(*sections) for sections in parse_input(lines))
+
+
+if __name__ == "__main__":
+    with open("input.txt") as file:
+        contents = file.readlines()
+    print(f"Solution for part 1 is: {part1(contents)}")
+    print(f"Solution for part 2 is: {part2(contents)}")