6 files changed, 440 insertions, 1 deletions

diff --git a/day-3/input b/day-3/input
new file mode 100644
index 0000000..fca63f0
--- /dev/null
+++ b/day-3/input
@@ -0,0 +1,300 @@
+qFdBBvtHHfvRlfvsqldvqjPpQmnQmjnjjjTRTLGRNG
+ZCWhhCsJCzSJzSbzgsmPTGNNPPNGjgLTLjgn
+WJZsbJMwJcszJcScwhVltFwBFBlqddvFdHDfqq
+crtTsGTtqFThGQGCrsjTwdNJwpRdnJJwffRClpSf
+PWVBPVHLvHHVgvZWBzmPpnfRSJJRQnSRflRPSNSl
+gmzBzDgzmZQWLDLLgVmDrqGhsscrqDMGhcqtqcFr
+HsbcdVrsbVbcLfPqqQsqqtPj
+mMBFzZRnmFMRBDnDFBGZDGdDqLjtdQtPtgfPfttgtqgq
+BZvZZdJMBFdJhSvhbhchcHll
+GNRSqRfcNTpfGCcqjfzBpDQPWBzgDpQsPWzW
+rrSdnVHlbMdLdBDzgtBtBmQt
+rbFwwnLFLFwlMLrFwFhMVLrGNSTfZTRhfTqjGJRRZTCNcf
+QWTnQCnWNNWmTnSPQwmqDbcscbpcjPjVPbrjpq
+vJhzZNlNNgdzgzJdlGzHHcHDpjsHqrvbVrbvrD
+RzRdRlhLgtCwCWSLnN
+SFTJFTTwTVVSJBnSTdvNNfWbZCZWNZCNNhBv
+srLrcHDcsjtLcLLcrLctjlcvbDNhmWCvNhZWGZZhNvhZmb
+rclgtMPrrSgVTgJCng
+DbrhDzcDffbzNbZvZWSSqSTNSVWv
+gCPltPmCPglFnPFwtGPhGPwTCTdZZWZVRvWqdRqVVdTdvR
+hLBhlmlstcffBzrpfj
+wFLLmhMfwZLDwmMNRhZwRLDvJgldbJHPdQvcQHHJQPgH
+bjrVrTSSJdQHcVll
+CGCSsCCBpspBrqbSttpbqWmWZRmfFRZhZMNNLFqFLm
+zWGjjBHGjzzTWMjhtDDWtPPlJZPJpvqQrmZTqQQpmr
+RFbVLcBVLRcRVcCsCCqvpCZqmplqQJmPrlvQ
+FLNRRSSRgScSVLLLNdFdwjHjnftBtGMgMjzHgzjWjj
+znVSqnqbqzSbzTHqDDZmlcFcnhDMnDmn
+LtjsvdvLJdjfFwRRCCMlChwCpMcclCcZ
+LgvjjfjFQVgNTgWq
+SJRJRFFCMSsGRMMwtZJRCVTgqgTVgTBCVpjTjmmWlB
+ccvnnpnDVqTcBVTV
+vPHprdHdpnzHSMsSrMRZJGws
+GddGrcGNHnGvnCHddvCSWqTSWsTwTWShbHlhhb
+gDPzLRVZgQfpRRFQDDVFDfzhSzsTBqqqnqbhnWTSSlST
+QVFfFgRQQgLtgffZRfpFPfntjrcrjCmtCdMMmjMdJJJNtm
+jjmNcpGCNmDqqsBfnZnGGGRLsZ
+lrmlVWlQQtWllgtbQVrWBnZsJgsRLfZLhZBBBffL
+rWMVQtrFlbFlSSMHVSdHHNHdcdDcddzppzzm
+bTpjpjcVTLmphbLppJwqzqwJLqqzzzgRLJ
+sdHNbrvNHrqPvZZZPRww
+bNQCrCNtNsSlhffhVhpVWFCW
+lpNnpMMZZDbNbnBjcrbjvScFmbGj
+wqhdqVqdscrjdLsv
+HQftVqWCfhwqtCCjWwfqzzVPZRJQgMlggZMMMZTNMNTnNRTN
+fvvGbFtVmtTwgtMT
+WcCcClzPCCcczJJScPWWZzBDmwbhBBHSghgDDMTHMDBD
+nWPljWzZWnbcbRsNFjFFdFdVjFsj
+NQrcLNmQGRfGLHHLZgbbnpjZJJJndbgnlv
+DWtThDWtzzhltWTwjbdpvjbgqjgg
+VtSPFWtBPBFSFBWCStshWBmlRfHfMRcfQLQLLlmCrCcN
+pbmwqJnqSJVwwDPCjZZzrZfD
+QtssBTvNdNvNtQvQGpGhdjPjDjczZDfjhgPPDcgjgr
+GltptQpMGNNpRWlWFVFHJFHLWH
+ZLLsDGGVhZcQQLhrLshrVFwHnWqJnWMnJJJnqfWfGn
+jMlPdTlPlgCgFpngFWFnJfpw
+TlTNbdSSTSTmTjPMTCdBPjBMrLDczsZcNrDhRNDRQRLLRVVz
+HDLpBqDVVTvwGDDNRT
+PlVWjfhsPMMmWtlFNTrhrrvCCCTNNbvw
+lsglfgVJmsfMjJfSqSzdZnLgqcnLnp
+pfCDJWBpfDffpJLgQJzzVzNrgNgNgNhNzmVr
+ZnnGZbGTPZnsnRFdTlbrwdrNzrrmmWwmwVwttH
+GbPGRvTnZljWnpqSMMCjqJQSCf
+ZgnFgwggznFrfrwfHhNMMr
+pctLCLRhPHBLMLWfBL
+JJcdJcQCCJmQJppmlgndnFslsVnsvghZ
+WpMgTppWGSWWJmJDpJcJJhqm
+zZzjZNHvNjPvNsbZLbRLzsPcqhVJSVttdwhwmdRhtdJRVd
+sLbvvCZCPSSSbbPfNlQQTQGBllCTnMnWQn
+fwbwswddwSbBfDBggMBPDPhHcPWDmhHhmWnWPC
+FQFlzLCzQTlrTTzvltFqFrmhPHjnhhnnchcJWcRRmRRq
+lpLzlFZzCltrTNlTztQLZfSMGBNdSBVwbBNVSMSbVs
+FMmgbTFdgLSgFQdjrRPrQBPDdj
+ZqqWRvsfGrrPvvPC
+wZzwnqccRwRNNpRSMztSMMFbgzLTFS
+qTwBPfTfqQDMDrssHdvtRHccHMjR
+gWSZGWzGFhnFFgnhNsRHtRdsVjZcRjHs
+jgplhpJJFgnDrrwfqprwDP
+CWhMSRfWhVVnRSZnVVdsLQqQMzGqLBvGMQqczv
+PHbpNwrjJplttvcclLlQzzDszc
+NrJbJrFNNJNPrmwrtbjtNmCfSWfWhSZZfSWCsfShfFVR
+VLhRPLGLRPRSStRRLwfGqfmDwbmqbqqDlD
+rBSFvppnzTbwDwlDcFWm
+MJrnJTMvMsrTsPtshRNPZdSLhL
+BZBrRCrnCQBBnZfGqhGGMMRcthMhMG
+TLjsCdDCPTvNssjdsPsDgsgqGcPHczchtHczWzPWzzlWhG
+gsTpsdNbvNNjNSpsNDTsmCnSVQFmSFwZnQBnmnQQ
+llbsNsWrmbrGbWCNtBjcCFBzQFZBCFjF
+LdSpwgdqSgzwJdRdLMRHLjQQjHjFHctjHBDTZj
+gSppgpSJMhpzwrhblfbhhlWlnW
+DwhTvvsJZWsBnDzPpBLbFp
+GHtNGRGNdzbMBBtmBt
+NljlCSVSHdjGSQRGlCQSCswqfWzhZfTcfzcJvshJ
+lmsGNFsDGqCbFQBbffjjwpzptw
+hRQdvdrvrvSngWnvnHrTMfzfzRtftzwVTwwpzB
+HnSSWrvLJvWJGFDsmFLPDFcQ
+bwwpGphpLghpTvpWphvJlFLJqqltjSjVlSStSR
+cmszZdDdBZzcNcDCDcNsmNMcqVjMJStFRJltVPVrlVPjVJll
+HcdmcCzzzQcHNcsCdpnGnhwGgnRggHvbbR
+CfMBbwBGbMbDCFrDvhFFDT
+mjzRjjRdSmjPnzFZgnnrTT
+cmSsVcHjLHTwMfLBpBpBwM
+whqqfZzgHvhSzzVNVDbpDbmbVbNpJD
+GcQFntGTCCcCTMCTGBlJsJsDDWpRbWBsJpNS
+FnPcrGFFdddMnCnTqgqgqPHfLjLqgSzz
+zMSzzjssFdGnszRtNftqqwFHbbZw
+RRPLVrgrwHqBqgwt
+rPWmLCTCQlCQQmmrWLrQShJshhzdhhJjcSjlzRds
+lvgvCDfPqLHppqpCCDJncbntttbBtBBVHjwtrB
+TdddszSQsWcngjzVbcVZ
+hRWsTRTGQhNRGhRTFSWmlpgfqlvLmplPqvvGgv
+LbWFLQdWWPwWSjSHPHRfppHHDRpggR
+zmqqNNzlzmnzzNCmVCmtBzpfGsfpBgDgspprcfcfsrRB
+qNNVNJtNmmmNzznVJzvCTDZWhvZZjZFbWQQhFhbZSw
+DjdHqJVVhHVZjhDHPWtDtZLFBRBFmSRTFSbwmRRTffTTJf
+NNznnGlgMQsnQzNclzpfSRSMRmfPMmFRwBwB
+vzrcGcNcPPvHvHPt
+wLCcmZwWTNtZNdMSMGSCnJGGMB
+RFbHsPhVvFPRjlshhrnQnGjQGSdSqJfqnQBM
+HhzVlFHhPwzScmSTgL
+TNlBhDNvNBFpJgpPPpDQ
+jjfCdCZZqsCZsbdqPgFGGMRzSFMqQMRS
+jnWPtWssCtWcmZbbtstvnrrvhVBhTNNhBHlBlL
+DZwNWPDzPVWbJngrQjrNnrQcMg
+GRRfttLBhhvTvmLmFcFcgFFSnjWrnsrG
+TLthBWtTRLHqhlLLfmhBqVPDJVdPwzJCPPZHwdDdVd
+GGVhrVSMQwQqfVssVvnWFgvgWn
+jtlcRBBtQRmpWsjzFCvzWnvF
+QPcRbpppDmNDtPPblZMfhZdDwdMrqSSGrq
+ZRrdtBdQvQsWnnfWFZsF
+bJLcMzNDLbMgwfnGMWFv
+lpvhmzNDmDmlNbzbmrVVPrHRCPHQBVCP
+rZllQrsRWrlQswccMVbGbVbTdcQQ
+NtJCntLSHCjznfLTcGGGqWMdWM
+jCtzzSFthhSSSjPJrFDlvWrlDZRpwpRZ
+mQmbLjbrLQjLmTtwwWBTTvWjtt
+BHSqdHclHHNFlppNqWPwfwDvTfDPPtCw
+ddSGMGHcdcMhMZnBbmbZmgGJJg
+lvvBzvDnlzjfPnfjnQPlldRbVbRqbqqCgsqqVpQQgVqc
+NNFtGNMtTNFmJNGNZtZMwVRTTcsCpVTbbgCbgRhscp
+FGNGZMtNLWmmJWGFWJGLSNtPrPnBfDzzvjnDBzpnvDBLnv
+fwvQRFQvQqwpwNJrwN
+BstDnBjhjBhnshSptpJzWqNppbfr
+CsDjCdZcBCDcjnfDHfhnfggZMGlgQVmgMTRmgVGMMl
+MwlBVqVlsgnmzwJsvjhWZhGPvjvRRWzG
+QNQpQpftHdHHCHGfSpCrQNdSrDRDhchhjvjcPrRRWrPvhZjv
+LtLSCTSGfHGdGwswnqsggssTqV
+qDDCHjzjznTvWshZQWfnZZ
+PFFmmNMMtNMVFtczcFPJNrLhZwQZQsSvvSvWvGQQJQssss
+tFzrrPPNNFlzVrpRTpblRDqjTpDC
+DWDrrBdpmdpBrCgDthdtfcHsqJsCqscqwfsjzHcq
+TNLNFNSTQNQTSnlMcczVJjVzsqLDDfJJ
+TFPZQRvvlMSPPtRWDtmDRWrBGr
+LWGVZdrvWdpLGWRsjPMsHmdHdHldlj
+zJzznChzzzCSfTgMhCPDmlDCbmlsmjDDQj
+nSTTJhJtnShNtzwhgNrGRRWZZRvMWMtVrqGp
+PbPmtNmBbPlqBvqlDJBT
+LpGVDzVpVZqqSTvq
+pMnWGLRLRppnGpGndrGPtgDCjMPmbPgCQmPPNN
+sqcZcbZZpcZspcCCRMmznWGWdLWhwDRGTTWggT
+NjFSJgVHrvfVtrGzWdSznDwLSTLn
+jFrBNVVjBFNvHrFHBlBFFpMslPgPcpMPmcQPPZCgpP
+frddqsThtsTfTbPcvhsrbsRLpRBNRpmDpGmRGcRNLpGp
+QWJHCJwWzlHZQZHQCJJRzRqnLDGRGpnGBRnNDN
+CVwHCClJjQgWCZVZQgMwSdthjrqvrSPPhdbqtPhs
+TvdphBBhhhCgdLNNJJJLWz
+fVcsqRVrPcnJWgDnJN
+JlqsRJtssZwqwVtPwltRPsHHbFTwTFbpjHhQjTQbvpTF
+cQSnPDDQJGNzwnNpZb
+RHDrssVRDHRgsRFHRlrVwzzpNGZlfZdppZdwGNZb
+sHCHtDgtCjVVLFChqPMhBCMcSTqB
+hdbQbqcCCQcqFbCbVdcWCQQlRMBtGlRHBtBMpHhpHThZMR
+LLsSLLfgJPrgPnssnmlZtlZpHGHVGfZVtZpl
+PvmvgmvvnzmrSsSLJDqDNzqFDQdDwzWWbV
+HNNjnLbpLGHvWJDhdWWPpWDW
+lVcSNgcSVclhRlPZPRCDCR
+cqmSQrwwrrVSrtQFqVNmFwjQnvjHzBbLLGjfjzHTzvnH
+QmvWVppPHQQvbbvmSHSpPzfzwnWMTZFFzwFMCzLnwT
+jGBljlNNjgDtGDrNjjtjqqDRnMzRLnFzCFnMfRfMzCnttF
+jqNrrGdJcdgLjqDqBrDQbbmhdQQmmpPbphmbVv
+ZHQCggVHHRDWvbfjGptVtLvL
+nnFwnwrDDMShnhFrFLLLpjvPlPGGtLGb
+dcNSMhrrTDCBCsWgCTQW
+HqDDLGtDdCnhfDnwnV
+PmlJsJTPlbdBTzTnzhnnCCWWzV
+lSPjMScggsScgjSMMbqHLFGrRLGHRZZtdrcG
+ZVVtNNppdZSdLtCPqnHhqJJFtb
+zgwwQBfwmGgSrDfgrrGBggzHCnbJbqbCJFnqhHBhnHHCqJ
+rvrzfmlRrgDgmrzfggvwzvdjjcccLjMjVcVcsVLjVSZR
+dppcLRHpphchhNhSddjzHzWQWQLtrMsrWQCWCsMZssCZ
+JGfBfJJfBqvGVlVbDBwDBDBfZnrQsMQtssMttssDsQMWZncn
+qPVwlgPBmjpPhcmS
+zGPnzBgPzPnPlHZlDDHnZBNCvrtcjcjmMcFzNcNFmFdc
+qQpfsLTTSspqTfJdmdCtMjdtjvJcmr
+bfQqqSrswLLrfpLTqprfTnDVDVBBbgHPDHnhDPgDbV
+JssTnsdFztZLdNJnNtTsLNZGqlbGFBqrGMHqHBcFBqMFMH
+CCgSfgPSvSfhpShSRppCdfrlqGHGGcHmclmqbbqbqlPc
+wvVSVjQSSQhRVvfQChvZZsdtJstjLNLZDJnLss
+CmfNNNZNqDrnDjMhZM
+gdczzGtdFcddtWQgGGMnVhnjJwnrJFDPTwMP
+dlvcdzdHtzQSLRSfmhLSqv
+ZpFFLcHFZZRRmJVZgD
+PzhrtQntzcrjCRJtbtRgBsBRVR
+zdzWfCzhQzlhWfWhlvpFNlpSqcMSHHMv
+NrrMgMhNQhNjQrtqtPtwVtZpggPw
+TfRLndnLFCRFTFbbRDHwpVqqBBwsHwZsfH
+TJFRdLlRThrlcvZcvQ
+scrwRVjbQvQBzsBC
+gMfVqNnVmnCBQDTvdn
+SMqhWqVlmWSmqMVRSJjjpcFrcLpJrR
+HtSQHQntHsHMrtHnGfHQVVzLvSBSVvVVSFNJzzVN
+cmPRmpqlpPmcgTlTpjJNjjVDvDRFNVVBFD
+hlmCpmqmpgqpZTlcdQHFQfbHHZttwMQwtr
+VpWgbgfwCjbftwVPPpGQFQhzTBQTBGPzqFTS
+dbRbDcRrsnsRrLZmLRDZldDZqTNTGqqFFzGGhSTNTFTzNmNT
+MlLdHlDDHrHclMMrCwgHCCwWwCbCCjjg
+GGNLhfDMVcVrcGsT
+jSJQFjHbwPFSvQSHwZFvHSHrqCCrrTsqBwNBrcBNsVTsqq
+QjZSjZJZPvNRZJQPnSZbJZRWLfnmgDlmhdhWgWLdMdfmhM
+CgGnzPNggCJtNTgTZTPZzZZvvcDcDDdqDFcJssJDHDqvHq
+jhhrrLVlmLRRnRflfVbFHHHqdVsDqcvbHVDb
+jWfWwrlmRRnQmPzZNGZPBNCQTB
+NzDDhwNmhvtrGmNCvWRVbcRRVTcHHcVFTbwV
+LgsPlLsQgQdJsLdldtpgFFTMbnFqTcMbHqFcPncq
+dgsJsLLLggljrhtGNNtSjvGm
+ptzSrZtzhsmmtPrhLFRFnjnnLMsnfLRL
+HvwVDHwWWgGDGdHgqVDWDMnRnTjFNTNjfLJvRRRRRR
+DwDgWgQbDDDHwBBBWdwQGVHhlhlZZSSmztfcppSBhzZcZp
+CWmWRzlMJqWDWqCJbqDlCBBVLMQHVMGrfMVtQZrsLL
+SnhPdFFPNZsBBdHtVQ
+SSPcFFgnwnSpwvcSjwzCqRzTmJbpJCRBmbbD
+wQbqGWWSqwrbGWWWGjbNMJPfgfnnDmPnPNLfjN
+tJFztRZCvVRCztZFZRVgmMhmgNLfRfnmDPNPhm
+BFCVZzpVFlHCdbQqcTcGlJbbSG
+tttfLPZZQZTlZPHHPWgMVvBnjmvjnjgGBQ
+FzcNDDDrNzprrrshprhFJtVGVnjtjGvnhvVnnjnjGM
+RDqJNszDPfdqPtlT
+QCJdMjCQbdBjSbTHDsbWDDwHTP
+zlvlmqzqGfgdNzLldrHwwPGpWDrPGZWprr
+gfVfRczVqcRzmdcSQMjQSQCSjQCQ
+RhhCGhRBShjjRfpwppFTfFHZHZZD
+qzdqzlnPPctPdmtPdTZbwQvvwqvHHvZpwZ
+nVTVTcsWmWSRhhRVrGVB
+GmshRMnzqRGsPNwMwcrrpcVV
+CDCbFCLvCgfDSFLslgDpwpLtTwwcPtNNtTTprt
+JvSFbSbbFllJlgDvlJbgdRhRdqzBGnzshZnRRRnHBZ
+ShJhtcsvvvQbnnsccVTLVTppWqddpVnLWp
+NdzPrPZgPMNNrmzpTzpTCjWfzCpzVL
+dZgHmZRPPZRlZmrPDtDRccvbtQQbJbRS
+wqjLjwhznhBLqLWGfvSlvcmlrJsqrtJTJJ
+PwbpFPQDRCDrDJTrTmvs
+gbZVFbZHgwHbCdpCRMnffNLhWnnzMdzLLW
+RVVGSNTTRlNqHblBNB
+JfwJMvLLZwLsMJwWMJfwLHBqzFlvzpBQcqzblFbBqblq
+wMCZJsgJCCCnsMHrgLLjSPSVTgShtRjTPhRRmt
+lmQSSWdMHHLWgWqD
+ZZtVGGGJrJvGVCwfgHNLccmNFFcqtc
+vrCGPhvrTPdRBnsRTmmp
+dDMDDjzCQjwCCcDgjSLLLsLNlmpplN
+FqrHFTFRLCLVFBmS
+JhHJhHRThrfPZPvhnTZZbWdwdwDDWtDzJDtbMtCW
+ghwDzJRDwHmPthncSPncLLsPcvnv
+MWCrNTCHrMVjQQMQcSdnpTLnFFdTcnTc
+qbWMfWfNrWVQWfbjVBbqMfwDtqzmhmRRzGhtHhHhRwZh
+fmSmnjTjrlzGlTzJdH
+BrhRRQMrgQvgFFhQQbwpFvGGdZqZJqpJqHVpJGJLHdLJ
+ggbDwQMsvsMQrFMFcWSPSCPmSsPfnnmP
+cmNVbMrrrjcHDRcvfW
+wQGdFfSThFsLhhHWvDCWDCJRCCjd
+LtpStGhqrrpnfnpp
+bvcccTqbgvpGndJtgdsgNd
+wDQwQhtQhQRmSmjsJndJdBBJBJnlLS
+hwhmRrzFVjtwzDmrVFrvPCcCMVPPvfqpCCTVVb
+jRrRNPNRWjPRWPRQNjQjThTCzBBzDCFBGzgDFGGQ
+dnppLwmwCnvtlqltvtnTGBThGhdFZhgzDzGccD
+MvnqpLlMqCqCHMjWPPHMSHSs
+NNpNNvpvBdtTrMFFMhSSwzjzchzwhzwL
+VVndHqflQZZZgHSLLhjzRSmZRhcR
+glGgnqbQlngnWCGJpJprtrtFrdPPGs
+WqwRjzGtRzZZRRGjWBJzjwmfMTHGGssTTDsrLmmmQLMD
+SNdvSdFlSNNhSPFFcPFclbQQslHmfHTDsTQMLgDTmHQQ
+CNcCFvpdnWpjWwJf
+PVPnVHcnRncGZqbVzHVPnnLbSMjwrzWMjSwDtWwWtwWhwDWz
+pTfsQCshCllpglWWSjBMSQSrMrjM
+hvpvppggCpJTvTmshgfsmZRRHqbcLPHZmPLRnmPZ
+LQbhVZZmZhZjBdbGmgHqnHTmvqgnnWHr
+SzCfDFFNRfsSFFMFfvprvpWzqzgqTwHTvp
+CDNDFJgMDSQhjVdPJLQG
+plpdLdpjjrrHJJjLrrHLFdbzzCcvzgFgcwggzPMFvvcMhM
+GRtSBQNsQlMPRzRlzw
+ZSTtsmBlmjLLpnpH
+hglGNVSdNSghzSgCBhDFLBMBtFMMFtHtbtLL
+frQZccRcqGFmFHrJ
+nvfGZwvTwGTfQwvfTwfgnCSlpdnzgzslppCsCV
+snTSPbQnTTnQgbmsTJsLfZwjffhpLnGRjpGfjL
+dcNWcNHHlNtWHHlCtltWNFNMLZwjpGfpmrZfrFprrRGpwZfp
+HmdNWCmDMVvQPDgqJs
+GGFtSngQLfnSnQffgPnRgFRGRwmRJvwbBbJDwjvTbjrwhJvJ
+WHClslcNNWcqNWlCZdcHsVrThBwBjbhDTDBhrvDZJTwm
+NWVqqcHHNpsNcNVdVlhCMlHQQMQQzLfzQPttFGPMLSLgtF
diff --git a/day-3/main.zig b/day-3/main.zig
new file mode 100644
index 0000000..4406a79
--- /dev/null
+++ b/day-3/main.zig
@@ -0,0 +1,38 @@
+const std = @import("std");
+const slurp = @import("util/file.zig").slurp;
+const dupl_values = @import("util/mem.zig").dupl_values;
+
+var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+const allocator = gpa.allocator();
+
+pub fn main() !void {
+    const file_buffer = try slurp(allocator, "./input");
+    defer allocator.free(file_buffer);
+
+    var iter = std.mem.split(u8, file_buffer, "\n");
+
+    var count: u16 = 0;
+    while (iter.next()) |line| {
+        const duplicates = try dupl_values(
+            u8,
+            allocator,
+            &[_][]const u8{
+                line[0 .. line.len / 2],
+                line[line.len / 2 ..],
+            },
+        );
+        defer allocator.free(duplicates);
+
+        for (duplicates) |char| {
+            count += char_to_priority(char);
+        }
+    }
+
+    std.debug.print("{d}\n", .{count});
+}
+
+fn char_to_priority(char: u8) u8 {
+    if (char >= 65 and char <= 90)
+        return char - 38;
+    return char - 96;
+}
diff --git a/day-3/main_1.zig b/day-3/main_1.zig
new file mode 100644
index 0000000..d65161b
--- /dev/null
+++ b/day-3/main_1.zig
@@ -0,0 +1,39 @@
+const std = @import("std");
+const slurp = @import("util/file.zig").slurp;
+const dupl_values = @import("util/mem.zig").dupl_values;
+
+var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+const allocator = gpa.allocator();
+
+pub fn main() !void {
+    const file_buffer = try slurp(allocator, "./input");
+    defer allocator.free(file_buffer);
+
+    var iter = std.mem.split(u8, file_buffer, "\n");
+
+    var count: u16 = 0;
+    while (iter.next()) |line| {
+        const duplicates = try dupl_values(
+            u8,
+            allocator,
+            &[_][]const u8{
+                line,
+                iter.next().?,
+                iter.next().?,
+            },
+        );
+        defer allocator.free(duplicates);
+
+        for (duplicates) |char| {
+            count += char_to_priority(char);
+        }
+    }
+
+    std.debug.print("{d}\n", .{count});
+}
+
+fn char_to_priority(char: u8) u8 {
+    if (char >= 65 and char <= 90)
+        return char - 38;
+    return char - 96;
+}
diff --git a/day-3/util b/day-3/util
new file mode 120000
index 0000000..40c3fc5
--- /dev/null
+++ b/day-3/util
@@ -0,0 +1 @@
+../util
\ No newline at end of file
diff --git a/util/file.zig b/util/file.zig
index 90849e9..c63422a 100644
--- a/util/file.zig
+++ b/util/file.zig
@@ -8,8 +8,10 @@ pub fn slurp(allocator: std.mem.Allocator, file_path: []const u8) ![]u8 {
     const file = try std.fs.openFileAbsolute(path, .{});
     defer file.close();
 
-    return try file.readToEndAlloc(
+    var buf = try file.readToEndAlloc(
         allocator,
         (try file.stat()).size,
     );
+
+    return allocator.resize(buf, buf.len-1).?;
 }
diff --git a/util/mem.zig b/util/mem.zig
index 89ba67b..3b68dad 100644
--- a/util/mem.zig
+++ b/util/mem.zig
@@ -1,5 +1,7 @@
 const std = @import("std");
+
 const math = std.math;
+const testing_allocator = std.testing.allocator;
 
 /// Returns the position of the smallest number in a slice.
 pub fn min_idx(comptime T: type, slice: []const T) usize {
@@ -15,3 +17,60 @@ pub fn min_idx(comptime T: type, slice: []const T) usize {
     }
     return idx;
 }
+
+/// Returns a slice of the duplicated values amongst all slices.
+/// { {1,2,3,4}, {4,5,6,1} } -> {1,4}
+pub fn dupl_values(comptime T: type, allocator: std.mem.Allocator, haystacks: []const []const T) ![]T {
+    var haystacks_maps = blk: {
+        var r = std.ArrayList(std.AutoHashMap(T, bool)).init(allocator);
+        for (haystacks) |haystack| {
+            var haystack_map = std.AutoHashMap(T, bool).init(allocator);
+            for (haystack) |item| {
+                try haystack_map.put(item, true);
+            }
+            try r.append(haystack_map);
+        }
+        break :blk r.toOwnedSlice();
+    };
+
+    defer blk: {
+        for (haystacks_maps) |*haystack| {
+            haystack.deinit();
+        }
+        allocator.free(haystacks_maps);
+        break :blk;
+    }
+
+    var dupl = std.ArrayList(T).init(allocator);
+    var seen = std.AutoHashMap(T, bool).init(allocator);
+    defer seen.deinit();
+
+    for (haystacks[0]) |item| {
+        if (seen.contains(item))
+            continue;
+
+        try seen.put(item, true);
+
+        var duplicated = true;
+
+        for (haystacks_maps[1..]) |map| {
+            if (!map.contains(item)) {
+                duplicated = false;
+                continue;
+            }
+        }
+
+        if (duplicated)
+            try dupl.append(item);
+    }
+
+    return dupl.toOwnedSlice();
+}
+
+test "dupl_values" {
+    const haystack = [_][]const u8{ &[_]u8{ 1, 2, 3, 1 }, &[_]u8{ 2, 3, 1, 5 }, &[_]u8{ 3, 2, 1, 4 } };
+    var foo = try dupl_values(u8, testing_allocator, &haystack);
+    defer testing_allocator.free(foo);
+
+    try std.testing.expect(std.mem.eql(u8, foo, &[_]u8{ 1, 2, 3 }));
+}