First three days

01/task.py

@@ -0,0 +1,42 @@
+
+
+TEST_INPUT = '''
+1000
+2000
+3000
+
+4000
+
+5000
+6000
+
+7000
+8000
+9000
+
+10000
+'''
+
+TEST_ANSWER = 45000
+
+
+def sum_of_group(group):
+	return sum((int(x) for x in group.split('\n')))
+
+
+def solution(input):
+	groups = input.strip().split('\n\n')
+	print(groups)
+	sums = [sum_of_group(g) for g in groups]
+	print(sums)	
+	top3 = list(sorted(sums))[-3:]
+	print(top3)
+	return sum(top3)
+
+
+print(solution(TEST_INPUT) == TEST_ANSWER)
+
+
+with open('input', 'r') as f:
+	i = f.read()
+	print(solution(i))

02/input-test

@@ -0,0 +1,3 @@
+A Y
+B X
+C Z

02/task.py

@@ -0,0 +1,86 @@
+
+# A for Rock, B for Paper, and C for Scissors
+# X for Rock, Y for Paper, and Z for Scissors
+
+# 1 for Rock, 2 for Paper, and 3 for Scissors
+# 0 if you lost, 3 if the round was a draw, and 6 if you won
+
+# X means you need to lose, Y means you need to end the round in a draw, and Z means you need to win
+
+SHAPE_MAP = {'A': 'X', 'B': 'Y', 'C': 'Z'}
+SHAPE_SCORE = {'X': 1, 'Y': 2, 'Z': 3}
+WIN_OUTCOME_SCORE = ['XY', 'YZ', 'ZX']
+
+MAP = {
+	'X': {
+		'X': 'Z',
+		'Y': 'X',
+		'Z': 'Y'
+	},
+	'Y': {
+		'X': 'X',
+		'Y': 'Y',
+		'Z': 'Z',
+	},
+	'Z': {
+		'X': 'Y',
+		'Y': 'Z',
+		'Z': 'X',
+	}
+}
+
+def get_outcome_score(x, y):
+	if x == y:
+		return 3
+	if (x + y) in WIN_OUTCOME_SCORE:
+		return 6
+	else:
+		return 0
+
+
+def get_score_for_line(line):
+	print(line)
+	x, y = line.split(' ')
+	x = SHAPE_MAP[x]
+	shape_score = SHAPE_SCORE[y]
+	outcome_score = get_outcome_score(x, y)
+	print(shape_score, outcome_score)
+	return shape_score + outcome_score
+
+
+def solution(input):
+	lines = input.split('\n')
+	return sum(get_score_for_line(l) for l in lines if l)
+
+
+def get_score_for_line_2(line):
+	print(line)
+	x, y = line.split(' ')
+	x = SHAPE_MAP[x]
+	a, b = x, MAP[y][x]
+	print(a, b)
+	shape_score = SHAPE_SCORE[b]
+	outcome_score = get_outcome_score(a, b)
+	print(shape_score, outcome_score)
+	return shape_score + outcome_score
+
+
+def solution_2(input):
+	lines = input.split('\n')
+	return sum(get_score_for_line_2(l) for l in lines if l)
+
+
+# with open('input-test', 'r') as f:
+# 	assert solution(f.read()) == 15, 'Not pass'
+
+
+# with open('input-prod', 'r') as f:
+# 	print(solution(f.read()))
+
+
+with open('input-test', 'r') as f:
+	assert solution_2(f.read()) == 12, 'Not pass'
+
+
+with open('input-prod', 'r') as f:
+	print(solution_2(f.read()))

03/input-prod

@@ -0,0 +1,300 @@
+wgqJtbJMqZVTwWPZZT
+LHcTGHQhzrTzBsZFPHFZWFFs
+RnLRClzGzRGLGLGCNRjTMjJfgmffSffMqNgp
+WPLgsfLmLgqZvZgSRR
+RbwHdbDdQFFFMvvMjbhqhZZS
+lzTdldBDszfGcRsr
+ZjnhJjMjnbdnbHdFLmmfFLmnCCWFFl
+PpNwtRsNsZSsRwCfzQQBfQszCBsC
+PpwcqqVZRtbggggjcgJJ
+ntczBcVcgnHzgBHnVntcBBFhgsmmmssqWNWNWqLvNhsqTN
+bSSGdSDZbGSGdDmLmGTvTGmLFFhm
+PlFbDpJDPbPdPbZQZDZlSCDBfMVRwBzBtBQzfzRHVMVRtH
+fDVrmmrvcmCcVpfcfGlswpPwsttMpjJMPPjjtP
+RgSTdndFLbJqqPssWWjPWjPjHS
+FqgzQnTqJRRQqLLhTCDhDCDmcmlvvlhcVm
+nnqVtHbfVHZVmtlvmHtZtrFSFTRRFhRccTbrLsLSGr
+cCNJQJPJQgjjMQdDrGGsRhTFGFRFSpMS
+gzdCwWdjNPgzcJgjwdZtVlHHmvvmZlvffHnz
+FFgsgwNwWvggQsMWDwvQQvQcccdcJZDtJGBtVGGGtcVlzt
+rjfTrbjpjRSRTbTpzldjjHBtJGBdltJG
+RbrPTfpCfmbpmnfRRCvMvQWNBwFFgMsgBL
+zzLHgjjjdFHWbGBjjzcbgQRmSvqsSpmRsRSQSmRMWv
+ZfJVrwPhZhZlhQQqBSQSNSqM
+tnCfrDCltfPzHFFLBgngHz
+DCpwrrMhwCrCMVCpGFqpVDnWWTWBtnTWvWfvbbTdFWRv
+lmhhcsQPmTtTnnPBTB
+QmcjNJsJzHNljZsNqDCGGhwqCqhgDDZV
+hLfRnSLfhcndCCPfJJjzJfzt
+pHNWwDpGGNJBZjjNNj
+gmgwwHpWTpmGDmDTggqHmmDSsnnhvcqScdVVSVcjLrRcnq
+CdlTJgnQJVCllNVWTPZBmPPGhGRmghPRGs
+wHDrSwtHbmhRvHVZ
+DzzwrtVFjLNnMTCTLCWW
+SppdsnGpNVnZZZLPMlMPGq
+mdcfvTTbBddLJgZJLlcFqJ
+fzTvfwjjfzzCbvvjvQjWvNHVNNVWrRtdnVNppNprDp
+lmlCGTmNbZlbSFlbNGfnzWfWzCdWWfVdwRCf
+jDHtHHvLjQtqrsqpjBBLprRzwfwJfzzhRnczhWQVwzVR
+rqpPtpPjDqpqDLtLrPGGFSFgPlNZZSGMPnMZ
+pSHShqgSMzVpphFnJMFMBtssdjRJ
+PZDbZfmCDgDfDNQPwCflCQNJsjRBRBFsdBWBsJRjsbsFJF
+DQvCwwZrPPlffDmQCDwZQPmPhqVTcGhSHSLTpSGhLHzpGghr
+gPqgqqmmmPgsqvGmsMCCnfZZfvBpWZhVrrZdHBvH
+TSlcttTjRTDlDDTRhZVdrHHpWVnfVrtd
+SFJzFzcJjcRJwGGqJMMCwW
+gzWNLSjRLzlNqqQMLhvQccGGmcQm
+fFrttPdTFTrpVwGpbdVQQp
+HnTBGfHTGzWWqCqngn
+SddrLdVpjjVSgRBszFswzwlV
+mtPMbMqPMvqHHHDTTglBvsFshFFg
+bmBHbtPctMtbMNMtbPtPqHmMjpdZdcJGrjSWWZGjJZnjndWj
+nljWJHRHGrDcMBbDLZHV
+wdvwmhghhbtBMcLtwZ
+gvQvvghTfPSmpmQljGFRjQbFGCsJbC
+BmphBWmDBBQfpVgQZpjg
+rqqGrrrqlnqqHqjNnVDSSSgQQffj
+FqLrbsLFsbLbLqHlMrmwwPDcCmMMmJBwDJcC
+wZccfslqZPFFjrFbFfQQ
+vvTvVWCJJZVBWCSvnVJJrhjQVMjVjzbgMQbjpphh
+BBmNWBvZRvSqwsGwssPcmc
+LGpnfcnzfzQdNFNHqHJptq
+RBNNvZSBRbRCCDJqHrDZqHFZtw
+SRNhRsNhWSNWsRRvgjngQnnMTnTgQjGMff
+twtZmwqBHtmqnnmlGLfcfvQQ
+dgMSPSMdQGclRRdF
+pVMrDgThDDlPWPWbBZtZqqttBqjqjT
+PPSWCGSzpCCQwNsNPFhTNVbB
+vqcgJngqLLcZLvBhNTVlbsvdFF
+DDmHgRjHZhHtGfWpQH
+sBLbwWWBvsBsqLqStRjcGGRnggjGcntJDn
+NCMQPMQPMQNzGGRRgRJRGzcG
+dHQNfPCFTQfFfVVNvwwJvSWSqWqrSqdS
+prDBnnDpFDprnDPBDQBvpBZttcSqSZSZcScFJSHcZJtz
+VhMVdLsjdqVWJSWZZZcHst
+hLVdGLfqjGjlfhCfCLjTTmrlpQBPBmvnrgDgpp
+SSSTJmmgbGwtmRZHCCZRCH
+FWcPQrrWqflzSWpRHZCZHRSt
+PSQzzdcQTghdndDJ
+cLlrNPvljRhRgTlM
+VmDBGnVdmJDnDBndnnVwDRvMgRsTbTzMMsgZghzzsB
+SpHvmGnSDJnwvDQqfrCPLpPLCfpF
+PppbRCCgpzzQCgCSgZTlNNTWnNNDNlRnGl
+hwMhLtBcBdjjNzWzlclcNGTs
+FjJFHJwhfwLHMLJLwPmqfQPgVCmQgCmCzC
+jTtMqFjMBqBmTntTztBTnTZBRZRLpLJgDgJNhghJrNNhhLJh
+DCDdvdGsVDVsflVdQSsfSwhRJlgppgpRpbWLgJbJpgbR
+wfSHSsdSVvQSwfwQPQPqHtFDcMzmtjBntqMTqn
+HQhQWLCSHCSCjnjQdSJdCSQgTTmZPTVZmqnTpPtnpmRmpp
+vDrzhvGzfchvlGvMFMrqVqPgZVVtZtVRgZgm
+bcvMfwvDsDfbvfwDbbdhCShWCBLLJWjHsHjj
+zLSsJNCjsjLCNLCgGcwBPPdwBwqwqz
+WMFZprZDbrddWRVRRDvlPPBcPhhlBqqHPGPhhffg
+VdbFvZWWWZZDFTLtCmNntjTnLSnn
+JLVhhwRbhVwcLFJFhhJcccqwsvpRlllvpWvZSBSSSRsNWpzl
+jgzfPffgZNspgZQS
+fjCmDCGnfmTfFqrFnhqbFzqt
+SfMRRNHSNNLfRfHcRRsqwdCCsssTqBCvgBLv
+llDDWQnFGtQnmtGQDWQFsgdHVBddndHsgqTsCTsg
+GzGjpWmWbmQmbpGGmGjHSrZcMfZSRPJPfcMRcb
+PDdMdRTRrLDSwzJvfSvJ
+FnjQnsqsFTnStvplhhzzFS
+TBHHCsgVRRcMHbLR
+GcLdGBJvBvLJHccJBvqHpGzDFfzwfzjwhDwrSFpfpDSn
+mZZrTTQVmQmlsMPVblZQVZmfCwjzzjChzCCbDSzhFjfnSb
+gZlRlZNPlmlgTTPmNRvJWcqrNLdvHWLBcHtH
+jWWbBwgwWwwtvvSCtHvgWsMFmscHzTGMmcssGFTTGz
+ZrLtpLnlfQJqnfJtpLnZlrqdNNGqcDNNFFTNDzzMMTMsMNMs
+LJQrnZnfLZnlrZflJJRVRQbbwBgCtCVjWgjBjjgbPjBB
+fqQVfRqSqmpnlLnm
+jFcjMJTjhwwggjFtgzCHmCzCmGzGlzpn
+wstMFFjWDfQRvmDPSB
+PgTFGPgcBZPcHPFBZRjGPgwCnmwCsmSdQdThmMMMQCQS
+JbpvWtvfHblWDHJDzmndSdMQnSwCdhMdQD
+rfvWlLlbtfJvvLJpqWbbqZRRGPVFNHVFgZNVFBgH
+TRMrrGBLMLPtbssTGtBHwZmdQQbdNzzZZNZZdwjd
+CVlVhCnclvhWSFFfQrWNrjmpNfwmjZ
+rlqFlclChhCvnlDvgVvRRtPtqTGJHRMBRTPPqM
+gZzCrQGQdrQvZHPTHWDbTgWPJM
+nSpLlcnnVjsSVLLnLSnhLSsJPTTWFsqfbPMFMqJDbfqM
+VwwnpwLnlPdQCwPPCC
+lRlrnlrsrMlhVsRnVhGPvCFNcPBDBvccrCGr
+RZQTzWTRdDNvBDdNcC
+TqjZbWRHmlMJgnmsng
+scQmLfQBQQvvZfLsmmvDJwpgSNSDDdcJSSwTGD
+PHlMbtzCCnlbztMRzlPNNdNwGpDpwgwptNLGpw
+rRHnLbhCzbbCHnHjMbzzjzFZmfQqWZQqvmhmfVZmqFBW
+fLTQWTMQtjcCGCJCbf
+gGsmsVSzmjCFHJCJgg
+SPRsSwSvBsPRPsqzwSVqzmhVWtLWhTDNLlTDtLTWGpNMtDLt
+mbzRbchRRQzzssLdhLggLddJ
+DCqDNNNWvDvjcPLsJcLLdv
+cpFCVNnVBHtbfFRtMRFf
+PFRcCCPtsDDDtjVspgwmgTNpTgTpspsw
+BqqqdJdHdMgSfMmZpZND
+vDHJGdLbLzBJdGnDdrBqVtCzWPPhthtPFzzPCFtV
+HvhvHdFdvJDfHdZdpfhrmGPljPRrGPPVDGrWWC
+NMMsRBMzcRRMMBSzcnbmNGrCVCWrCqPClmPqlG
+zLBbwMzQnRSQMThtZFLvpdgHtJfF
+DpcJcJPmMcLSHHZCfpnH
+BsBFvvqTFlbhgdbBBblfZLCLzfHWfjnjLCnCrh
+dTsNgqFvNgsGlZJRtVtMPmtDmG
+LdGQqzPGCCjJTJdTLJQJtFcFRSctcrFNFltPFtcc
+HphMMbbMdBMHbBhhgHMnhvwFFvtrlSNRNgcRllcvcc
+spHMhBnHnnsmWdnsnMBMdVGGmzjzLmZLDQCCCCZjqjTD
+DDZMzcTRgDMLzqCffhfWfcWnfj
+NsHVVJmswwSSwNPPNjnhqhnCCnhNvjfTnv
+rSSddrGSGrlMrpTpQT
+bbbfCfrLHMMMWVWC
+SqsvNZqQvvqcjNvqZsMMwgFgFplTHQVRFgWH
+BSZWWqBZBjmPGJGLbBtf
+RNCNfzfRHmzHwSdRdGfzRJPqFcFcDFGccZZqtLtGLtgl
+pjhVMhvhbjvPcDJvcZqt
+bsQMTsjppmSdTnHSJH
+PtLwpSwdSJwQnGvvqtvMhZ
+TlFcHlTjVjsDTQnCQhbZGCVVnb
+cjljTslTrlzzHDNRfNgLSNBJfBwNfG
+HvsZZqqqwWZswWHTmHsvvfhSfBfDffjchfBbhD
+MCpnCVpQClRNnlNQVQClfDhScmjBfLhmLDGbBNbS
+gmtpJpQQllJnWdZWwJWFwJJT
+TzBvBwwdhgRPGHlRHh
+NLWttJsrLWttppLpsGlsmVbVGRljGDRgjV
+MlllnNFnnQqCdzqq
+vptzrJhMMGGMptJPhJGJPvdFTFcSsTBVsczBScTSFFfn
+gbRjWgRjCqjZnfHCHnTSVBHF
+mRwqNbmqlbbjqRNlLbNrDJntNDGtDhNpGMrpvJ
+GPWZLgWqLHHGbgbbGPPmqHqfcjjRHJJBDRBRjBBjMHjwvwQc
+dhpFSpzVSSMSlDBvMQ
+TndsVNztVTspnsdpshtmZLPCGGNPfgqbWWfDGb
+CbqDjjCdClqgrfJvrv
+NGNPtGGzzHztPWWnlgJvfBnWBFgp
+hGzNHhsmGccwHPHZHcwdCCdbTVRTvSmTCjbLCb
+sqnqsHGpJbqnrbshpshHmmmCWZZmWwfTjTjHmfLZ
+dPggRgSDDttMFgctgdDtDcDcRWJBmjTWwmRLBLfmwBBjZWTB
+PFcVPlJPglbqhhrnnlNz
+wZdDNDdPPfhqwWqbsF
+VTngRzpnzMLvzTCLlhvDfltqqDttqFqs
+mggTVpCDDSNjBmPZrd
+cSdqJSTTTJcSJpCdQbqTCPPdjdDtGzwzjDwjwwwwzD
+rVvsBBVgsVBhHhfljtgbPgGtWjPtwt
+fvHsVZHVnRHpSJJRmbbSLT
+lDDPRRjwLGlvVRDRPlwwwPvmpSfhVWSzhqfzqpHpVpVHfqSH
+qBnqBNsBBChhCSfZ
+nTQbQnNNQJTLvlmTPLqqmG
+TTCJhDrmDpRVhvhHfffwzwfz
+dmmdmglWcqvHvWsHzB
+gdQMZbtlgQlZcMSttCNmVVrLSTTJ
+PLZLqhZZzZLBjjjGrrPjMH
+CcQcCcfRlWDjdrMrBrHC
+WlWFMcFpcRFmsWFcmflqSJzTqzwLvshggsZJwz
+LgqRDDDHHGTpgpJrQrQhhhCqrwPw
+ZSBWjjFshCFlQDrJ
+SjWnnbWtWnsztgGDDbDTGgHHGp
+llfvMlvzjzGzGRfvMSGRfSdStrCtQNCZrrFdJJLnNtLZ
+shhhshPHsTTqsBHTVTwTwZZnCtQrQnJtQCCJBCCZdZ
+TPHTPTHmDnljplfpGfGm
+qcNTmvvSvTNrWhRrTdthzW
+bDVJphpMMJwJpMHtrrttWsgwtzRW
+bFpGJbllPfplVQmnhvvcSmCFqq
+GTPJGMQTPQMqZjHTBmnndBVddHrrzNrz
+bbcRFgDpptRbffwmzmrvLmcZvmLmLv
+WCwgWbpgwtgfpfMlQGPhSPZWTZPl
+DsPCswsMPBMwPDCVJPnTPPWFGJNJmbJW
+RvvddfvftdtvNzghGSbFnWTntJSttGbG
+LNgRddgRlgzcgCDjjjHjcBCwcM
+gnVtgBnpwBgShBgcwhJJhjCMMMDmLRjDRMjrDMMMDMqMRF
+slsblHPNHlbTNbsPvszHQWbzqrZLMRmFMFmdFmrtDFdMLNZD
+bPzfvbfsvvlHtlzPHllHGTlTppCJpgcngcpwnwCGGJnnShwV
+cgQRgtzDbHPcgHzQWpTjTLdjjNNpNLsDss
+nwccZBmwcJqmJnjsTvmlTSsdlTNs
+CCGFCBVrBwwGBhqVnZBrqWMMQzHfQcHzzzPtfztGfg
+lhnwnhlbgbngbcfDgJLJQqDdVd
+FSrvtMFZVJJJVtcq
+jZNNNNjmjSPjFTJmGGzswwzHwHpBsbPblhhW
+tnDWHntzDtzQBZLMLzNLDDcRFFjhJBmcFRCTjRchcRvT
+sqwsPlbGfSbPGSVbJfpjjhcTFmCRjjvmTTvRdw
+lJqSqPVbgGSGrVSqJqflbWZQNDMLHnrQQWNDMtQMQz
+lpltwwJqsWVLPtVt
+DGHsDdZQzHLSLZcFRrFS
+BGsGCnHmMlMwCfwT
+nrRNzRMPrrPnNwNzTSFSTNtqZdtMttvQqQmjdjvZpgjZ
+GWVhGcGhHhGcffbZGDmmtttQvpdtbpppdj
+HGlHBhHGJfJJhCfZzLTTNnNrTnCNwT
+jBpCZStjBwWrQCMrhw
+TvcHBzHdPPzdvFTzzJlvzdQfThrhhrhfQTWMQfWMqfwf
+bzGJJBJcJvdvBPFzddGgjZSbZZngRZNNnnsjRs
+dqPqbpPFJfsFfMcNQNNtNmzrNQJn
+VVBDWvwZWDLwGlDhLGWWVcmQtSNmLmtSdSSTmrcQQm
+lZlhwDCdhhHllvWvjMHbgMpgffMggpPb
+SWSFLLFWDSWDNFzmmLMfGlfsdfnJMBfwMGVnBf
+vPtgZcctcTQQZRRcgCtZwRfqBVGqnVTBGVnqlsdBJnqV
+RcjgwbbgNSbFbhDb
+JrRZLrHvjQFPLnnBPQ
+DhwbtHbzpcpFTgtQ
+zlDwlHlzWSwDqhMMbSJVZVvrCrCZJZNZdJ
+fgNCZSDtDfDZTrTfqWghQGzGQshgpGGFQg
+RFvLnvFjnVjmLQGPQWLmWh
+MdwwVMFbMdRHFbccbCZJtbDJrqqJZNJZCZ
+fdZVBMMdfdfBCzhTzMdMCgCrGGrpQJmSmGJGmpJQVpLmqV
+RbFnhNsvlDsFHttllGmqGpPLvJpmPJSqLL
+tjNsDnNwbNjttNNZTzhMWzcZcMTwMd
+DjSSMShjRjPCbDFCdCSDbpBBswfNWZBZZrBVBPNfVmVf
+zltLjLqqGlzQntqqGztqcgncZrVrmNfNwWBVrVmrgwrfswsW
+qcTqHLlnJzGznLJtHGhMbhjFhMMpFbpbThpp
+ZVFZcctFQzsCtbZFnPPHqmqpwmvPmp
+NrjGfMgcLLcfdLqpmRwRRqJJmdPw
+LMNDgMBGlgGDLMNDGljctVbVWZTTCWChhTttsl
+RMGRRhhgzgZMtHdGTtvDwDJFCDvvwdvwqFFv
+rfrrjLNmmSnSjVSmNNPPbJVbqvqsqvhvFqCq
+flrpnSlrSNfjrNjSphNSWlHRGzTgtQGHQtttBTRBRQHW
+tplDDprhbvprvrJDprCpbsvHRfzSzTtzmRqSTznRRBRnSfFF
+MVwWjVNVQGfcMnTmRnBm
+VQwGLNLjWNWPGjZbsDBppBZhhDvBlZ
+RVVrGVVchRZsnzRzBWZb
+FQHWWCHwQmWmlqfCHSwJnsbNJnNsvttntBtb
+QQSFgqgqLMLPPdWdMVhWDT
+cZrMjncTdfJpPJbr
+WHNqnQwwCwvlqHtCtHNslNlvLLPDfSVdVPVDVSfVSbftffVf
+NCwwwQwllwnvgsvZzgzFZzBzjGGGMM
+MvHpfzcTcZzpphhbsDSTStsltqSDtS
+PRmnwCrWnWQrmNMRNnlNGbqlbDltdlbDtNtD
+CRJnmRVWJfgMLvcz
+HPFbHrrwLdVdgbDZqcphCqSZBhLZ
+tQRfRRGtvTNNSGTMjjmDCRhmqpBChqhsRDZh
+vjSfMzGQNQQnMtNTTWNNjgblFdFHwgdJJHHPwddgnr
+BggPRVBPPgfCBmJTjTTqpTNpZBwMbr
+lclLLllsQLFlsbMqNrMwTpwpcM
+SvbDzSDbWFJfWPPgdnfR
+GbpSSbGDNbSSJbDZNZbDppGtMntHLHvHCTLCJMHnRCMLTT
+cdwddjBfPsmPPQqQqscnHgRMtngvtjjgCCTMzM
+WvwPvWvflBwdQPlNVVhbDGpFhNGhbl
+WZRGmRvpCRFTZMQQQMCdddDDcD
+lqgqsgvjVtbMDzzbtcDQ
+NsNNgjNNjsNhnSvRmnpGRmSTSG
+nTgFtDTDDLrFBStdGdcHcbvGSc
+QPzfPCMzWCjfMPJhWGlRbRWRWrRRdVVH
+zhCrCQCjPrpNNBsNspNnwq
+zTJpqFzbTzsWsVbbfLGfSSCDNSBCHfMLHG
+rZcvtmhctrvmlPPmmmrhhmBLCHDCCLLDlqMlGMNDMwDC
+rRhRhnnQPZhtZcZtdttZgqFWWVjssqQpppWpFpJW
+NWPhdWJPWVzVqQrqmSsPbrPP
+cZDRjGsffGsCDfffgjGgRQSrTcTmSlTrbnqmSSrlln
+fFGCjGCjLDLFRgfDHZvzLVWtvsWWBtzJNWMB
+qMVbtnmMMTpCppsR
+NffHGrWzWWgDBfTRhChCnSCWcnjT
+QrlQBPBrlPHrrQlrHFLqPnLvVvbVmVVJtq
+MVMpHMZLVCpMrfWjvWnfrJ
+hlblzDDzwlSlGtRhRlSdrfGGWnWWfFPjJjnfqWGF
+lmlhBRlDhhhDRRhwDmBpHJmsNCHmCgNHJCJLsc
+jvsLgmqLgHvbPPVbNjSCjC
+pwTcRpRWLRMLJJFwBBGWcFWNVlDDCSTVttNPblZZCVVDlP
+GcdhccpcpRpGRhGmfsHHzLQQHrmsnh
+FMmSRgtMltMnVgnmNvlrsJrsZWjspvsZJp
+QbdhqwqbNqdHbTdcbcpsrpvjfWfLJLfwJrWp
+DQBBQqQGccdTPGqqBNtFGRSMRSFGtnVSnnmM
+fPjGrfFrrprprdrbQPZwlcZwZmlJwH
+qvNnvWnvWDvSvqNtWSLWStqbcJBQwQJwQZHLBZbcmJbblb
+DMtvqSvvDtntCRfwzGCgdzzFjG
+TfdZgtmfDgqgvlLFFsFHvcvZ
+pphWQMVjQVVBWWjRlHlHnlcLDDhcnF
+JQwwWVPBwMJpJwpWwGBWNzrDzSSzfgTPqTSTTtSPgt

03/input-test

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

03/task.py

@@ -0,0 +1,68 @@
+from itertools import islice
+
+def load(name):
+	with open(name, 'r') as f:
+		for line in f.readlines():
+			if line:
+				yield line.strip()
+
+
+def priority(x):
+	letters = '_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+	return letters.index(x)
+
+
+def find_common_item(rucksack):
+	first = rucksack[:(len(rucksack) // 2)]
+	second = rucksack[(len(rucksack) // 2):]
+	intersect = set(first) & set(second)
+	assert len(intersect) == 1, 'Must be one letter'
+	return list(intersect)[0]
+
+
+def solution_1(name):
+	return sum([
+		priority(find_common_item(l))
+		for l in load(name)
+	])
+
+
+def batched(iterable, n):
+    "Batch data into lists of length n. The last batch may be shorter."
+    # batched('ABCDEFG', 3) --> ABC DEF G
+    if n < 1:
+        raise ValueError('n must be at least one')
+    it = iter(iterable)
+    while (batch := list(islice(it, n))):
+        yield batch
+
+
+def find_common_item_in_group(a, b, c):
+	intersect = set(a) & set(b) & set(c)
+	assert len(intersect) == 1
+	return list(intersect)[0]
+
+
+def solution_2(name):
+	return sum([
+		priority(find_common_item_in_group(*g))
+		for g
+		in batched(load(name), 3)
+	])
+
+
+# ASSERTS
+
+assert priority('p') == 16
+assert priority('L') == 38
+
+assert find_common_item('vJrwpWtwJgWrhcsFMMfFFhFp') == 'p'
+
+assert solution_1('input-test') == 157
+
+assert solution_2('input-test') == 70
+
+# RUN
+
+# print(solution_1('input-prod'))
+print(solution_2('input-prod'))