Day 3.

2022/day1.py

@@ -1,9 +1,8 @@
 # -*- encoding: utf-8 -*-
 
-from pathlib import Path
+import sys
 
-with open(Path(__file__).parent.joinpath("inputs", "day1.txt")) as fp:
-    lines = fp.readlines()
+lines = sys.stdin.readlines()
 
 # we store the list of calories for each elf in values, and we use the last element
 # of values to accumulate

2022/day2.py

@@ -1,6 +1,8 @@
 # -*- encoding: utf-8 -*-
 
-from pathlib import Path
+import sys
+
+lines = sys.stdin.readlines()
 
 # the solution relies on replacing rock / paper / scissor by values 0 / 1 / 2 and using
 # modulo-3 arithmetic
@@ -11,10 +13,7 @@ from pathlib import Path
 
 # we read the lines in a Nx2 in array with value 0/1/2 instead of A/B/C or X/Y/Z for
 # easier manipulation
-with open(Path(__file__).parent.joinpath("inputs", "day2.txt")) as fp:
-    values = [
-        (ord(row[0]) - ord("A"), ord(row[2]) - ord("X")) for row in fp.readlines()
-    ]
+values = [(ord(row[0]) - ord("A"), ord(row[2]) - ord("X")) for row in lines]
 
 
 def score_1(ux: int, vx: int) -> int:

2022/day3.py

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+import string
+import sys
+
+lines = [line.strip() for line in sys.stdin.readlines()]
+
+# extract content of each part
+parts = [(set(line[: len(line) // 2]), set(line[len(line) // 2 :])) for line in lines]
+
+# priorities
+priorities = {c: i + 1 for i, c in enumerate(string.ascii_letters)}
+
+# part 1
+part1 = sum(priorities[c] for p1, p2 in parts for c in p1.intersection(p2))
+print(f"score 1 is {part1}")
+
+# part 2
+n_per_group = 3
+part2 = sum(
+    priorities[c]
+    for i in range(0, len(lines), n_per_group)
+    for c in set.intersection(*map(set, (lines[i : i + n_per_group])))
+)
+print(f"score 2 is {part2}")

2022/inputs/day3.txt

@@ -0,0 +1,300 @@
+LLBPGtltrGPBMMsLcLMMVMpVRhhfCDTwRwRdTfwDllRRRDhC
+gNFJHJFgtZFJjZJHNNFWZWZwwDjCwSDhfCDbdwjfwDTTDT
+gmQNZnZNHWnqmQpLtVLMBsPpBqrL
+HlHldQtHlctzppdQtjdczHhJRnnhGNVmVRJmVjCVFCNh
+LgWNgggZJZGFhCZr
+DbqPswwMvDPqzlBNHtzfHdwd
+tJgtJwwCtNvPHHPtHzDsdRTsBRDDWgWTgT
+QhLQjLGjZQFlFZmnmGLDrzWfRldrTrzTBRWTzs
+bFFmFZjhSFHvBCvCvJpb
+MSGcvnvMGMJgWJDpdndZwBnppfCp
+VPVfQQVbshZNZwdNDwNs
+LtLbjmQRLmVhQtTbfgWjJgFFcrqqrGSqWg
+fHfCNCwwHfGhcntntrrgHrQnrn
+FVqpSpbPpjSVMjqvVmVvMzlzwJnbtnnlzQQlrWzJgt
+PTqqRRPSRSmqSpPpSpRZwGCLGscCNLZZZTNdNZ
+pQQQslVSVzzCQnZSlplzbLcHZHcrrrbZqFbZjbFm
+gWtvPgdMDDtFDHHjJJbbccbrLW
+MhNvwwDfDfdtvRQnpFNNTlSRSn
+ZTnSnTTzqvFmVzvWWm
+ClpCgltHNrtgsHdpLCHtDCNLVvQvVwVmwcsWQGMMQvcGcFcv
+JmrgCHCNJtlmHmNhnJjnnnjJhPfhSJ
+BgRRZTgHHvRTRmRNLNNhQWlmGFfJlWlhsQshpF
+qPqSSttwnnzqqqwtVrPwMthFsJllJJlGhpJhWJQlhVQd
+MjMwScnDPzcwjtqDtztnctrvgNZTTvCvLgvQbLbvjTBvBg
+SWQSbbqTTbPcfMZSwZZwwn
+dghjghmNDmGsGgdnfmtMRCLCCRncfc
+pJDJNdsNMMhpssgdprBTBzWlpBWlllWb
+TwNLNZTwWCWLwWCSTZSLzWHGrDHHPmGdDHvndGdNfvMm
+BgpjtpgjBjVbRjQRhVsDnvgGgPnGdrmvnMDfrf
+rhRjRssQJplRtVbpthblbbLSLzFCJZFqLLFWCzqcqzLL
+PBrdPMtBPvCQBVBjCfWPqSHbszhGGnsfSG
+JpmDwJgWJgNzmShhmfSGzh
+pRwNcNpFZNZRWgcNplpjVCMVjdvdMQtCMLZjMZ
+lDrcnnlLqLRcDDZRLjFVTHzGCLGVPzGPVWGB
+pNwHpdmsNJsbpwsbzJTCPWTVFzzQTWCQ
+vbhswdtdwfdsmtNSssHwvllvMcZjnjcnZqlgMDZglM
+GVVtJGtzVFsVsDTH
+mQRgcBRmRLnBjrtFjCCrHmFF
+gqpBnlRpgZcvdSdlMdSvMt
+tMSCNGSflffNhnnGqlPPsrzWPrTrVpWr
+bZHbmDBQmbDZQdbDcRFZZBTTWWWwqVzszWjrFPVwrzqq
+HQBLHmQVQLDdCggMfgMNLvNG
+HHNDzNJPJPmdPcNGGGhnhwnVhCQBwBjQ
+bsSbLfrLtRSLRSRRRsBwhCpfpCzlwCBVjlCV
+zvvsvqLtZqLtzRsqTrggRMHJNWJgHHHNJcgWNPdHcH
+qgbNvqbgmmZgZLvZqgnZzlpzpzHtVPzttGPrrnnl
+jwswGjQDMsQMjdBwdcjCHVtcPVpCVCrPlVSrpc
+GsFWBfhGBfDFDFWqNbLNqbgvqbbvfN
+HgwWqtcqHNWgnHcNNCfvJCCJJfJGvnPfrR
+sbDhZSmdBbsSdmSDdrjjffRvdjPrprCd
+vvZbSFFlFHtqFqqWNc
+ZRjnbRsHlncZGjTRTfFVSQBQppQvvFBHpF
+zrLwMdhDhqJJttDQSldQVPQSlSfPlV
+hCWWCzqWnmcZlRRW
+HfgfQflHjWgRQRdRBWVsnbvvscbbbwvmbHncSc
+tJGLtPPGZPwVvSSPhw
+CLGTLZqJtMGqLDFFDZZJFZJpWjRpVNRWpllDpjlBfgVjlp
+rhhGZZhLNhPmfJqvfLlq
+dHRTHRHQQWcTCRTHmmjJgfqqlGmgWgql
+CCwRzTRRdCCRSQwzRcppprZtrMhGBMZMnDSt
+WfffvnSnfSBshwsjhlvGlh
+ZHpFNTmppVmNzVVmmFMZzbwwjHGrGlPhCGrljbgHsg
+pLZMmqVsZVMMVVscDfdtSSStqcRRdn
+RhRbLzRLHLCPmzznHLbzCRTJhdTVSJJVSjdFFNFFNTJv
+MGgMfpMsBgpnMtGfnfwBtDBjFVdNSSSFdvJSQSpTJdJjNv
+lMsBgDMsblmRblnz
+ClNcJZttLfLvvRQzQWwRQN
+hrpMdqMspsrGDdMphhdMMMMHBmRWmSVrRVzVTzQBQvSmzVWV
+ppHDMGhMMDbGMdDMGbgFbgbMlJJnjjZtZfLPcfcngZfPPfCR
+ZRslLRgCclZLZzQghQhfrbfGbJ
+pVSHpBBBBDVDqDBldVzfrMzQbfSTSJrzzJrJ
+DqqHnBDlpNDVVnpnjtDtNjCvFLcsFFPZRcPsNNmPcFcP
+LmLWSmSRNdcpcRHFHrWzWHbMbwZlZlPSbTjlwPbTPJTf
+DttBsvhnhqvGGBhGtBVNBVqJlPwslMMPJwTjZbbZPTfbPs
+CDthQvVNVFCHHWCFdr
+RRtCWSzQZdRMrtRWrSztMggcGDfQTcfFTGqTLgGDLc
+bnVhnvPHhhdJJBTLDGcDTcBvvD
+pmbnhmPPmHwdCjmdrRtCdj
+lTPzwhzmHpTvrDCDHJnsNN
+tdgtbMMBbWdFbtqJCnsrqnMMDsrq
+FjWdtgLSWttWtLSWtDWBjGGmwGlzTRwPTQGhlQQm
+wcbnTtTppNLrntznTBBccCGrVldRrZqdqRCZdFZCVZ
+JfHDgjgPPfRRgRlLRddR
+jhDhhLMfmJjMjDbNSTzbbbtmttmN
+CfGlvzpvpTjzzCWjvDlfvbbJbCRSdSRhsSQCMhdbhR
+wqrSmrLHHNcLqrrLBNsndssnnhPshnsQwbnJ
+NtcmBLcNVDWzjSvWtv
+vZPCSCvCJffvVvmCmPqCSlDSscczHDRcwcHzRlRHHs
+LFGFNnGrdQttNMFpzpMRRDslsJwsJH
+gjtLnFBJrLvhZvCbZhqB
+DBcjVFjDhQMSJVZbHZbl
+nfmsqppnLfTnfmMmzppwgllSrbSHHtllqbtSwZ
+TRzTnfRWnfdzWssfnRfRpncQPBhdDjjDCPcMQcCBGPPj
+NSjWCHjNHjpPWPpSFWdtqBMBBFVBvqvJGJwqBt
+gQllgDrnhQQDGRshRsZfVtVMRqwMtccVJcBtvRqw
+DQrzrDzhQgrsZLrZjWSSHNTWCjjNGTLH
+CgdcCFcbTbBzPgmNRmpptP
+rsZtsvVvHZZzPmqVNPzNmV
+HZjrwrjnjtHSHwDGdFhCdhWWJnWchCFJ
+RMTqQMRJqPtBtGBPtWjN
+ssHfSfShCwwbhsbHhhsmSfhSGNpCpNCjBBBLptcGtpzBBBWW
+HnwrSFwffHsFwrSSjfHglJJlTgZdFdgZRZTDDM
+pDLDWlDSlJDmzSJnDScRPLGGvqFqLPccGLgv
+CZHfwNMVNjsHNNqPgcbcBbRQGQ
+dCffZCjVCdCHHTmnlSgTlTSrlStp
+bFtlLCvLlVjpCGPJndrrMMCDDCnrMg
+hRsTwcZcBjZRJrfMDnsHrJnH
+mNZqcTSSBTScNzVQFtGtjpFtjmGG
+bjHdLrHjRWpDCtLzhzps
+lZcGfTvQcQfvlqqcNCcBvVwtGzmzthmwmpthMDmswgMt
+NcqflNQTBTTvvQSvqSVvQJbHPHbHCRJdndJPSHjWHb
+CVmRncrRVrhcmsBgfmtfdJsJmt
+bZHvZZDJwpWtdZgtGNGd
+vSbwHDMFMJqPQqQvvSPQqpSwjRcTVTLjLRhVCLFLjLFnFzCC
+mtffsmBwfwBDBmmsLsHqtpftGrMVMPSMPsVvhNvFrGPMvjNV
+TQTQCRWjJcdcQQSPrhhPSvVGPF
+cTRJCnldWJZlTgbWgbdbpqfqmppjmtljpqzmjpLw
+NNPmrmPWmrSSNNPmnglghmCvLCCflh
+LFbsDQMQFtQFHbQHqhvnngCftpcllptJgJ
+bDjsGqLLdRVjPZPP
+tgrbBQlbtRblwtRGrbCNswDDCsvFszpssCss
+SJVMhSZfHvpdhphN
+SMLpWZSSZMjfgGBgRtbQgljQ
+HsHHNDDHzHDDjsVBBZqtWBrSNcPwQvccvvdhPclSrQSc
+fGCFCgpgTfnTmgTFLFgccclhwQhwrzSwSwrCrr
+pmLJGfMRpFmfFMzmgGmRpgmVqWJDqZqqHtjBBVDBBqqssJ
+mBTfcfCCmpBCCSzNQScQSTfddhdtwgttjghNwGtGdgwGtd
+HvvqbvMLnFZVVPjJGRGzGRjZtwgw
+VFHFbsFHHSmzQBmsmT
+ZNmZCmNHHzzmPPzlbplvhbQh
+GDSwldfdvggPfLvQ
+ddqrtlnJDJlnjScRmMRCFHTHtFZF
+FPvglHSPcpNcFNSHFHNvZjdmbwdbzZtzsHDzbsbj
+MMnBLCCWBJCnrCVWCBstTZdZmdTtbDLswTtZ
+BMDnRCrnGhPPSgcgpG
+nsbgpbdrjMdGqnNRRWWRww
+tZZhPzCJhsJBtJPllJBCtCvwwcwwWLvWvwWRThcGcqLq
+mlBmZQPZmlppbgMmfssg
+RFdZTHFCdvjhgGnFqj
+zQLtNQpzNNtNpDtDPWLNMmGfBcjgjlgjhBnvcfnBvfjp
+PtmLsPzQVWzWDswCSwHbRZsGZw
+nPsfnPsFhTGjqGnmQppG
+RZhBbNwbBRZHZSCCHQqSpCpqqm
+VMbgNWRWMDfhtFJT
+RWhRPDhBHZWgZghRZwZgGJPGdncFdLcdLCjscFcjCjNLLj
+mQfSrlfTVqmSVTTTrprfFLqcdLHsLHFnvsFFqnNd
+TtQmVHmMrbMWRggRPJZP
+TTlCTVTdcpBlcchF
+ZLhwSMZhqhtqwqLjFcBvFmvvssGBmmjj
+LwSMRtqMHnqhhRZRRtJSVTgggVPdTdrVbQDJgTPW
+CGFFWFFVgjfzgVfcJCcgTCcBBWqSqMMBMBShhwMLMwSSMq
+fmQnflldltBZqlwqNZpB
+dvtnvmtRtsPbzCfTHjHcPzGf
+hzshzfshVhthgMmRsFRvFqmm
+PDDcZWlWBbplvmRRGtlvqQ
+ncjnDjbScnBWZjDVfwjfrrVtwLjzhr
+QRWvffVVGfDhNNjzGZLLcGGZ
+rgtpSSHpPrHSspvNLFlzTgNLlFglcc
+SSpbMHpvmwMQhMBR
+dHLtBqPCtPBHNsbRNdNNsZVN
+nQwntMwJWhwWjvcjDMlntRsNpgSbNNpglFpVggbSVF
+QDhJWwhzJtTqLzCmtT
+PSLqTqrCrRvCSJWLdLwdVWdQWL
+zNjHQnnHjHznnbDMnMMMdVZcpZZJpZWcdJFZ
+BntfgNbzfBtHzgnbbbPPSstlQSSGGrlGsrTT
+QpBNsBzztgqVtdmp
+jvrhGljRhSTlGGvjwjSwGjRvHVdqLttrMgMbtMMMVmdqqHfV
+ChTvTvljmCsQQQnNsQ
+CQCNSQHHgCtNHCNHHNDJcBJwLPtJBGhMPPPJwM
+zRTqmsdRRzrmdzVRpzPwcjdwwhLjMBMGBBLw
+hprmzRmblTzTVTVrlbrmVHNWNnCZFWNNFZlnDFSWgQ
+hGGqwwdwMqsRDGRBzlvDzB
+LTNTfcCFFFCcNHFFBzRSZRBlzHPSZdvD
+nLVTFNfVVLLWnwnwdrdbhnrhrr
+hlTpcDTpHmHwDmMbbdMMMGTPdGPR
+ZzFqNSQqHvBvzzqjFHtvSGRRMPQsJGJWRGWPMRdRsM
+BZjLNqNqzVVHgLVgll
+ZHHBzSZPVqghJgSnBhqJRQLRRMvQpwZvfNQRMMMp
+ctFCDmdDWmDGNRFMpRlwwQPP
+PrsmDmCGjtcmdjGtVqBSjJhnSbHnnghH
+QmZHTjmmHRmmdPRvHdVlPdrNNLqWzffbRtqpzfWtWsWNNW
+gwMcgnMGFGCjJLqfbtNtzzssCW
+DwMFGBwcBFjhBBhcDSJQQVQTPldTvPlVVZQSdQ
+NRTGfNffLghStLRR
+QlnWsdJWmnbWnVqWbWqHPSpmjgCjtSwhPjgtptLS
+JWchnllHqQJzGTZfTcFNDN
+VtdtcTVVCRctVdJclCVtpphpPhNGDwNPmThwWmgG
+ZjZMFnfBqqMjHZHMzBnzgPGwDmhmhDPfQNGPQGfD
+BbgsnFgMgMlVdJtlcVSs
+tlBMdBnClhLJnTbgph
+PhDDczqDGPqsHGrRGPWHGPzcFJNLTTJZLNbNLfFZgTbffL
+sHsmzzrGmPrRDRHqhHwmjBVtllwtdMdBSBtl
+QscfZsGsVjVtqGmlzvRMvl
+ThJNCHPTDDhHHJTJPHmlSMTtTTlBvlnMSzqn
+HhCdrHrCcpmmdVmb
+WPPBPvRWzvhWhWzGWtBqBSTLDZhgFSTCDgSgZZDCZs
+flbJmMJnjdMqNdfZZrFZZNFZgrrsTZ
+nQnqJlJdlQMMbVnVmdMplVnnBwcBPGttzQcvtHcWwWtHRHvB
+LLsmpJTWCJmJppCmgHCCLjbFtRFghzjfjcjcZttbRg
+SZlMPBdBtQfFSbSF
+nPqldlDwlBVnvdLWJVsmVNZCCVmJ
+HWvNVtHWJjHJsSgHsHzsDsmf
+RwZGPFGMQgzpTGSD
+PZMlwwqhFPPZqwFhPwnFbMjWJNNBtWNVJlCJJWJjWWzj
+frBSzJDtztfNVGwRzVgGhqsV
+MPMmjPWGMMmPCQCcbmRwVhTgVwTTqjvRTLww
+cFpcMGFplDHfBHFS
+gtjhjLffmgjgmbgVfbNdqFJMJMNbbwrwqq
+sWHHPSJsHzTZzTGsCdrqCNNddGdGFGRC
+ZpzHHTZWzsSSnBBPsTBnLVcpQfcJcQVQDQfcDfQt
+qMPqChqjQPRCMqlBrmGmLbPSsTbSvz
+nWNHZFVZZttWpfHsGSbBGTbWBSGmSm
+nZfpVfdZdtFHnwVHZtNwZhCJRJhcCdDcQhCqDSSCQc
+LlwSlZrftFSMpfLCdltTmmmSDmJqmssDVJBmJB
+cRcGGhpvDTmTDgsG
+nNPcjpWbNzjRRcWhbzWjvnLMddMLCwtdtMttddtrCdMz
+NszSsDCMSDzdZpCMCSMpNszfTvJhlvmlmrTfrhlhHPrmhD
+FRWBgRjWwqFWQFBBWjVncjRTvJfvvJvVrHhmVrHhmrdJTh
+wnwnqwRGFqdbNNtCGpCp
+zgsBvPVVDDrDtDgt
+nTHldmJQNTTfflcJNrQlHWpmDDFDFhWpWCLtFbphCm
+nTTNMlNfHQZTQPGSzVVZSVPSwr
+bPLbtPpwsJhlpnhnnLNNZDWhRNzWQrWWffNr
+SczqFdFHSTFjmMSMFVqFGCWWNRrWQQQRZCVWgQQgrZ
+dFdzFGHvjmqGMFwwLLsPnvBspnsn
+lwJwwmblVdvjbbbJvVnlmjGTTNTLqffpqDJffqGLqDLD
+ZtWgPtRMtQRQnTGDQNTTqL
+gCztMgWgchHhvwlllbnl
+cCwSSCVbqwCCWSbZMmGdtBllWBfdlvdt
+jzRsJjhPjnLthJNNpmpvmvvMfGvjQpGv
+nPHPFgRHLtCHZrqTcq
+dVJwCJGCVrQQGTNtLtGm
+hWWgDHBzWWWpZlhWBssLDTDsQTLLtswswL
+gPhBHpjwHcljpggwwWqvbFvdCVRqPPnnqVRb
+zRRRRNqzpQZNNRRmRcZscQcCDmCTTTDGfTbfGhrTCTrbFF
+HMvMtjgtLHVlLVfhCGfrfhJhhrvh
+LBgStjnHBjLVgggBgHndnSNNQdNWcQQNGZccwsccdQpw
+jLRqmZNGtZtvZvHzPfCvSSzhCP
+QbwDVHFrVbDVrDFbzPwSThSfddhWPWzS
+rpnFDccHFHtZNmMmRntj
+RFVdzzlNtrwSTltb
+hHGcqqBcGLQZffHhMwSswSWGrnnbMStC
+cgqLBgQgpgbbPbPz
+lfcgglhfTvmlBvclbgztnSRtSmttwRJwptWR
+FMjDjsdNDjNMQLFFLCMQdtwGGzRwzpGwzdWzzJpGhn
+ZQVNsVZMPsVhCQsFCFsHHlqlcBZrHHfBflbHBB
+vGGQQdwNCTJfQJHJbM
+FFqmzghlzhgqjlFqzZhmhPlRgBDLLRTTcHMbRcJHBLcgRH
+qFrPjnhZmqnhZZjhhmpPzZmtvbpwtdvsSCCsGwdNwvwNCp
+nrFdSHScdRwvdvRm
+NNpPLJJbNbppCvmzbHTbmsTw
+fWLHPlPtpMNBgGQgqggQSMGc
+BcHtrBcnjflfHslsrnltbTgvMwpWnnWpwwwCwCCRRW
+dzGhLSSGDdPNgLLdPWTqWWRMqwRWpvzMMv
+VPZZNhhNSSDhLNSLdFZBVgBbjHcgsgfrbBJbfs
+VMnWjjWTnNNCzzhblbbjlj
+FmHwfFHqpDrJzPQLPLbCDs
+GrdFfHqqSmmwHSqHfpdMNTtTtZCMMZtTRggGZR
+QRlnlTphqNfqdjZNmd
+rDtPmGctFrcgDjJcNjvNJNCcNw
+bgGDtgDbBWBSBVlblmVmsRMmLM
+CcQTQTrrmfQQhZZBpZpSSZ
+JFqSvLlLbWggDvDDFHjsdnshBZpjHBBhBW
+FgJqNvLRMlMMDDblrtfrTCStmCVtNttz
+MRRbbddqtHbMZbqMHHTFTFgwZglWPfgsZWgW
+LCcLjzCNGNcvpvLTFPmzlFsfTgFlgs
+NhNGcrCGrsrvcDpvVcSbtHQJQbnQbSdHMtJV
+bfMfBFcWFsWZHBWRPQpRqdwmMpmddm
+rSShvvVTNVhvVCCvThDlSvCwpGCmRmGQmPwmpLRLRdpq
+DhRzzVNVVgSzTFcgtnbHnHbfBB
+HsTGHHvlvvGTGlHBvlbZstrVrwNjrjVStwVVZR
+PPmgcFJPFcFWmWMgdNtVtQZtDVDVdZZjjR
+LLqWnMnmNvlBLCTzCT
+qTttLqLvGCQqCDlhml
+FJjzrRBrpjRWrCwrBrrwpRbbDzgghSmmNhPQhgNshmDSzSNm
+bJBrbFRjBVnWBrRBnHLfHGfdVtvHttcCdT
+mTzjGPmPPmPNjNBTvlJRlNJzZqrzrSZZSpcZqpgcgcggFr
+QWCwwMwWWhVZFbpQDSpSJS
+stMMsWwMwVWtwJTNNPvvRmTsNPsl
+gGFFNWMMNFTBlLpGpSll
+qvccssdDwDbhMhzwHLppTSHLrdBpBVLV
+PhJhzhMJzwDJwhZZtZQJCjgWtFjZ
+pGqWfqqGcspGqWqppHprpTrzhCzttMBCtbtJmtJbSBvWBt
+QDnVPgVPgDCJBMhmBJgv
+NlZwFlnnPLLlFwDlDlnPPFFHTMTdMZjTTcjsqqcsdfGdcp
+HLzZfHWWQwpgVHjVHr
+JlMlMGGDMtJGdtJhqtlccDgVCSTFFSCSDTggpvFTjSgS
+JcGRMlthtlVNMJRfzWsPnQsnnZNZns
+zVfvMpsbtQmtBlFWBZ
+lLSrlNTNRSFRFhhHRmPR
+dnSJjjwJJGwwnzVlvpszvccM
+SmlcCrpnrnznGzSBBSfzNbtsQsWZQcFbWctcbbZb
+JHgwJPjvdghbbWdDZGNLZb
+JjghvvhRwhwJVhHTzmfRfzGSMrzBfnGC
+JbCmrbnzmntnVJjbCHJJFQFvqgJgQgqLDQ
+NGhhhhPMGhWsSSchWlNsCLBBlLFQCgqvgCFFgQBg
+PdcNWWcdGdPssPPNTSNNtzbTwjntzbbVwtZpCVnb
+tGNgtsNQHsJmwwzddmQw
+hMhhDBwMhDDfCRRBjFDDTTWjdWmrmdWqjlmmmjJz
+RSpSSBhppDhRncRLswZLGvtGvNcNtL

README.md

@@ -0,0 +1,7 @@
+# Advent Of Code
+
+To run any script, you need to pipe the input:
+
+```bash
+cat 2022/inputs/day2.txt | python 2022/day2.py
+```