2022-03 in zig

4 files changed, 384 insertions, 0 deletions

diff --git a/2022/03-rucksack-reorganization/example b/2022/03-rucksack-reorganization/example
new file mode 100644
index 0000000..156e424
--- /dev/null
+++ b/2022/03-rucksack-reorganization/example
@@ -0,0 +1,7 @@
+vJrwpWtwJgWrhcsFMMfFFhFp
+jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL
+PmmdzqPrVvPwwTWBwg
+wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn
+ttgJtRGJQctTZtZT
+CrZsJsPPZsGzwwsLwLmpwMDw
+
diff --git a/2022/03-rucksack-reorganization/first.zig b/2022/03-rucksack-reorganization/first.zig
new file mode 100644
index 0000000..38c6d0e
--- /dev/null
+++ b/2022/03-rucksack-reorganization/first.zig
@@ -0,0 +1,33 @@
+const std = @import("std");
+
+const example = @embedFile("example");
+const input = @embedFile("input");
+
+pub fn main() anyerror!void {
+    try std.testing.expectEqual(solve(example), 157);
+    const result = try solve(input);
+    try std.io.getStdOut().writer().print("{}\n", .{result});
+}
+
+fn solve(puzzle: []const u8) !u64 {
+    var it = std.mem.tokenize(u8, puzzle, "\n");
+    var tot: u64 = 0;
+    while (it.next()) |line| {
+        var i: usize = 0;
+        var middle = line.len / 2;
+        outer: while (i < middle) : (i += 1) {
+            var j = middle;
+            while (j < line.len) : (j += 1) {
+                if (line[i] == line[j]) {
+                    break :outer;
+                }
+            }
+        }
+        if (line[i] <= 'Z') {
+            tot = tot + line[i] - 'A' + 27;
+        } else {
+            tot = tot + line[i] - 'a' + 1;
+        }
+    }
+    return tot;
+}
diff --git a/2022/03-rucksack-reorganization/input b/2022/03-rucksack-reorganization/input
new file mode 100644
index 0000000..595d32a
--- /dev/null
+++ b/2022/03-rucksack-reorganization/input
@@ -0,0 +1,301 @@
+jLnFTjhwFTLFDGDDvLgvDssBJBbVRNZJPPJBGzBNRVJNRB
+QWmffSmMZCfWrmHlCflQWfSNBpVBNbPSbbJNppcVVzzpcp
+lflrqrWMmfdMlrtWWmZgDjsqwFwhFDsngnvhqs
+CNBGwsWVsdWDNCCVvfPLfQfgZHPBvpgf
+qhJqJlmcFnhJclllPgZjvpHpvfZpPbLn
+lpMJJhhcSMDMMwws
+jphtLMfVpjJRjJscMJptssnrwdNwQrNbwNzQTbcNrwQT
+gSPPSqGGGrdLrNQGrr
+PvWPDvWWCSSBBZPjLVDfhjsLLsDhtR
+hlLwDGLNnTrbNdtbdb
+ZfsvJbsJTrsttHTR
+vjPQJPFcmZjVFZFvbbVcJZJPBBhLMnDBznnGMDLMwBhlmBBl
+JdTJFtwHjJTzPMqPccqzjB
+rggffSCvNBCbWBWt
+ZsSpnnRpLStrZpTDwTVwGTJHDLdH
+sZqswsrcRpCrsCsrrbtpbpDlttlFbbpGtj
+LhNgNvNNhTQMhQMWhvvhfWhllbGGPbPtlPmFlDbjHHdlmg
+ffNBNMhDvQDhvzhBhNTBnSzzrZCZnrsVCSwcnrCC
+hHGhjLjwtFGwGhhhhtwjtlhrDBQrRBHczRcMvsBcRrDDMH
+TTfbZdZbPbVCmCdmnZmCVdfrJBczMrrznvBvQBzzzcBscn
+fdbPZTVVfSdmbfdvjjSGljhhtNGGhL
+fMrGQbPrbnfljjzVLQzNCzVv
+WcDqlSpctSJNzSFJLCzN
+hBBWcHtWgWDmZlwwrsPrRTRTMrmn
+ZJTVdgpzPpLVVwZgPzTPLwgWdhcWhSQCbcSbBtSWdSWchb
+qnDGnNjqDqNlqsCSWhMtlMltWSQB
+NnNrFQGjDRgLrgrpPr
+nCrhsmVrlrzsTvsnVvmTTlpvPJPWWMPJWWPCJMPNPgPJMjJj
+ctDqBLHLRLBSBqFRDBFqFFNGgjjrGGMrWftWJPGgwfGN
+HFcqZqqdcFQRQBdrlnplhspQlTmmvlph
+mllQMvMTMMdNNdTzTGmLgWjBgGtBqWHhGWjHtB
+PPsbbZPCVfJFJRJZsBHjjHhHcjqSSWBt
+wCVJFVRJDDpCPqZlTlwQnrvzmMdmml
+JfCJtCwfsffBJmFmgFmFhhdwgV
+lzHzsSHvSRlDRjlHTgqVVmmVPZqqmggmqS
+GzNNRTWvbWGvGQtfLnbfMbJfsC
+FnPrwqrFqsPrrsrwqwnbZFPwBQMhhdBHQZhTVBMdDHVhQQVh
+zlLWlLvLgtgbMdhfVDdzfd
+NWRNjLmWblGFsssNnSwPsw
+gnmCjzwnmCPTPhBwPjzBgqPjllJJSWlhfhQDSrpJRhDSlfJl
+rLHNHrLHVNbVHMMctZFHsbcsDSDWpSDSGfSRsRWSRllfGSSG
+NNtdMVrLNdZNvLvLZrzCndqBgwwPmwgjggBn
+tGSBRwwStBftfBHRScHwfcrCgQgDnjQhQDqgBqgCCDnnqg
+LNlbZmlPVNzWlLZVFPQqgDTQTmjqCQDQqmsQ
+bpZNZLNNZlLNLZNNZbLlbLZbwrwSHGJSwrGwRtRpcjjtMttw
+JvGNPWhLPLBffwhGCrbgnFDbgcZwbVnb
+TqzSTlQzdHQQpTTjSddHTSnbqnZDcrrFnFVFVbVVcbhc
+mlpdjhhTHWBmWWBJvG
+ScrppccsbMRRvltvrvrj
+HRTVTnDwDLJJJZwwVQTmNlvqBNtvWBBBQvhNfqlB
+TLJdLLCJZHJCVHHTwRdcsGpSbgsczcdcgS
+tffHzJctHsSHHHGTtzvttZFlZZhVjglVmgDhDdjgjS
+qCBMCqbpqfQPMBPpPljQVDDZdddZdgFlDV
+fWwLfbbWNzGGrzvWHJ
+VnNFqrrJdfQhCDFPhttD
+pGpTTzHmRTNTTLRRtbBBbzhPtbtbPPBt
+HLpHpmSRHTpllcLTSgVvNrJVfJvqMnZN
+tHzgwJCgzZlLFLnWJTnc
+NnNnmsMnBDFSFWdqssFd
+mDMBNmRRjjMNnvrPnjjRQQvfRgwpgHHpppHhZbzfCpbHtH
+TTwBnnZwBnNQZZWLWTTFNFbsCGrGFCNvDDDGFj
+lzPRfVVRMclPRMRcbFDjfCCGvvsdGCDd
+hSmmlMlVztlhRlVbqQpLnWqSqLZZwZQT
+zzVTcqmVqzdmhZJbFpQZQQtLLWLLbp
+TGwvGgTnGTRHLNtMftWHNbWf
+vljTGwvvlCljsgSnCBslDPPJrPdVzrSmhdqhVDPP
+LzCGCGLBGNlLmFFmmSSBBqSc
+ZJfbdfbWtbgVlblJtjcFcqTmFqqjtFHtjj
+QgZhZgQVdlfddlWPhfvMCGRGPDMMRvDNGvND
+nLdpLJSSnLMwjCDwnQhw
+NZGNgmsgPtPTgWqqCGwRbrDCQbCwhMjr
+gNqPTqTPttPZqcWfHLlBvccFvhpvJc
+GNdGhMMvRBjmMVjM
+trcZJJFmCgfZtcrQCfCZSpqSRjBQpQRQBbBqsSqR
+JcTmwtTtcrmThLGDhNTThvNW
+ZqhmtzzfZRsSfRmSTThMpLNgpgJQThMG
+jdnvdHWFvvjFdCWFrvVVnvFDQrJJMpgMJGNLJNJTPPgQGJGR
+vnHjDVHBWjdncDRbRzzzmmBsSSzt
+VZNZSCPTJPpvNTNsCrbnVrLccbLnnRVfWb
+MlqQBlBztFlhQJdFhccbhnRWWfnggfGc
+lzJqllwQtmzdHZpvwjPPNspj
+wTnCMnwQCQvTTJdfqhdtrrSmhttmmm
+LZlZglZBvjgbHHSrHpbr
+GWvPjPNGljBzMzJVMwNJMw
+CSlChlvPPGvdddqPqSJhPdbNbcMTMTbDbcRNDFcFLMLJ
+HWjgngmBZGQgRRNbFRcHbbzT
+BmnpnQBBssBsQBnPptSStllGhdCGrS
+nhQCnCvjchBBjMNrwbRwZvvSvSWW
+qgHlfqblVbPfVqlbGgPGfdfLSdNssWWLZsNsLZsdNdLSZZ
+gbGHzzbzHtPfcJhczmMnQBJn
+TTGJJPPZJGRzDwtQjTjzDC
+VbnrmNVWVWbffbVMsrbrnvFRjzCzQCjvQDDStDFS
+MhrRfMmfMmsHgsqPLLGdBqJJGHqd
+FMCMbmSQTHdCBmpFHprdHcDNqqfqJdJsDcclDDZlNf
+wzwRjwwtRhnzjRBWRnvtnWtnNsfsVDlDlsqVNNNqcqVlDvqf
+PtnGWjtwLBwtjCFPFpMpMbSrQm
+PWzrtrtzBBfjjWGbfNWvLJLgVSjRLVlSlllLpS
+HhZmHGGhGZRpQlpLpL
+dTdnHCnhmhcHcntrPPGfzfrcNtPz
+PfmWWWPwWdPdWPTVCdpjRnzhjDbrFnGbnQGQrrDR
+LSBnZLnJBQDLRGcQGc
+NHNqqBqvMMBsJgNvgsstBHNsdwwfTtwdpfTTmVmnWmtmWVlp
+zjzwTHCzDzbDzNTDjzDCCHRZmmSGmfgPmZGtHtgLmf
+hsqJMcQltLtPhLgL
+QWWWcMsWFJssrnsWrdlcPBwNTdzwTvvBvjwpTbBzpT
+LRvWZdLzzZWSqdpBzLdzLgRmbHPVHtFHMFFMCtHCfHcbVcqb
+sGGjNDnGTnlSSwsrTwcFVMHwCPPPcVfVHwPM
+GDQsDlJlQhSDTrpvhhWBLWvdRvWh
+sWhhdhdhbHSVBbFLZLnnCmCmtTTCCV
+RcQvjNrcrwGNcGNRJJmTpppgCCgppNgTtFmp
+GRRRGRGclfjwRsbfHFhWBDhdFs
+jfRTfgHqgDZHClcPcrGhnbcqrr
+FztdMLGBzpFJpcnzzclblcnbbl
+pdNBtdNLdvsNtdLpdGLTZDTgDjmvCZjCRCDDHg
+bdrbdZbJtZhrMrWRHHvRHRvHllqZ
+GGjCNgDVDFsCCwFNHjlrPrlSRWPcSlvl
+CNVDgDwVrQggDDQVsDwNwgTQdJtbfbLhtTdtLmnfbJMntnft
+mjznjLchnPPcLLnwCTFFvPgJJWdqJqJJdJJr
+bMlQRzbSBbRBMlMfMBBZFrqggvVvfqdDVDVDWWFd
+ZSSsRGQtSpBBpZMSbSpZsbtsjhCHTHcLCcjzjCwTTHhmNHtT
+ThCHLCfVfDTtDnDppTqclFfSclNrwNPwNfFr
+JmsQjJPJMWRRMddZGZWsdsMZrmcqvNSFSwrScrvwSwcccFFw
+ZWdJQGGzPJsMRZBGtHLgCHTTVTLBDtgn
+JVGJfttHgTLVTsnHgVHfwVBDjQDNQSjQwjbNbQjBbddS
+rPvZcZpcvtzcZddmNQjWQSjDpp
+rrRZPzRMztFFFqMZFtRVgnsLnVHfVHqJnghHJL
+grrZZbJSggQDLgrvSSDBVsGdjHjnGnBGVsLGHj
+pCtWtPtffPRcWdBsGsGRBRvhBj
+zmvNNclfZJJFZQbN
+DDqCgPPDgtDSPPDbgCqcmBMBTQLQZBWwQZbsMWZZMw
+RNlNvpvNvndNjMZtBpwMTWLBZt
+VlNJvRzdlGFRFGRRRjFVJRRggtPPHgHzgStqCcHHmHqcrc
+RfmdFgbtFLHlsjRPsL
+LqrhvCTvNNhWBvBTrThrDWZrPjMQPQMcjzsPcQHTlVHQjcMM
+BhhrJWJLvCbfJbwgtgJn
+FWpRfFRjtjFpVvbTTZFPhJhJLdCLdWBhPmHmCW
+McMzNlGrgGGsHcqmdLqbhJmd
+lNMwsnMzzsSSGtVVSfvZTtSppb
+JrJQDJDVvGwGVwvcGCRRcCBBqsWBRZqWZZ
+bNdmhvMpjmHbNbpNvmbBqlRWlCtCqlRZqRtW
+HmTjNdmMfTTVvLSzvz
+WMQWmfGfQfVnMGWGmGtGWHzZtdLzpZhwrtZcwZzdps
+jBgljNPbNjPFRbggNlNBCcHsrLLLHlrLslhlzdhdHppp
+BBPBJbFCTGJcVQMGMv
+fdmfmmjbPmjlmfhfGglTNLCNvPNSpPvpvSLCPCpS
+MtJwMrwrZJVHMgqJHtwVJzVVLCvpNLvDrLvQSQSNcCNpFNLS
+wWMVWZzqqMRHztwJZzRqVtjGlBdhbGGbThhTlnTBTWgb
+ShhrjPrvhlljnHrggPvvSqRMBZZqBTZmMmTmTMdD
+ctLzbcpWCJbNWRQqBBdZFMBdfZdJBm
+GQWpzLcVpVNpRggHrhhgvnGPwj
+PdzSrmmqSgWWddNQds
+TZbwCTLZbHLWptQHhpgNsc
+MZjBLjMLDTDqrrGflsjjrf
+DBHTnlGGBPjPmwRWhn
+hgLgZccSrcMgLMSpCLJjNWmPWjmVWdwJjd
+MfQMScQrMSprrTGHBhqTvqlGQT
+CDvLRCCzQDWzcGQGvRcpVFVsgTsFrgllrTpF
+mjbqtHqHbspspnMv
+ZvvqdqqHvLhDhJWzJd
+ThHnbRTVbQHSWvBVVBCPBW
+FFJgfqfqNwNrvDCBNppP
+jzsFfqwqssLzJjffJcssHQHQdnMdhTGHLbddbCnn
+gwMHHhbSwnqHrgMqMbnBcldhzBLQBQhBLtLttQ
+dCRmpfvpCzcQllflQz
+TjPsCJmvZPNPsvZpPTTRCpprjdbrHngqDwqMrDnMbMbHgM
+CgNQpgTCgNltHTNQlHpRnRnzBfJnPnmpcpfq
+LGrrvGSMGvrsWPBmnJPmPfmrqr
+VGsSvdJvbSHVtlttNVHT
+LnZDtzpzNpPsCbfBbDCDBC
+gSGRSSghqhhSvSRvvhvVqFJdsfBsCHJbVfddCJ
+vglRRjQSmnQQCNrL
+HwhVddVVwRcGHGjlfS
+MbBvDBGvWqpNWvMbzDMNZZlLcjlSclflcjqgfCRg
+bvDWDWQbspPPWWQMnGdnFnJtJFGJhhPJ
+nDJDdQdPDlDJnnbRQDlTqVfFwfVtjJjjFfqqFqgN
+hScrSmSCTZvZCSmZLFwfffqgjfhNGwjhfw
+zCzsCCTcMBmSLmsMWHdPWRQPQPddDQ
+lzGflPZLSqSlccpqjpdNCwjdsjCnCsJp
+VghPQDVMFQNdJjRNBw
+tVrhDVmHTlPlGrzL
+gfSJJlzvGgRPpggR
+VLDDHhHtlZnnZqbGmtqPmmmmWN
+VVDBnddDBFFzlscC
+cmmzRzcRjFrGncTHqc
+ghJfwJJvqhbrdndWgddWBH
+fQbSpJwSthbhtvpCwqQbsDPMNLlpRmplzPlRMPzM
+bBVQDgBpTzbhpgQVhTmBVBzgrvcnrncsnZrwzHJZfnHcZfrP
+tdWlFLMHGFGRGMRLNFHlfwJcrPwcsnfwcvZPfr
+RLWGjHLjSjtjmBQVgpQhhg
+ttRRJBrCfpprmFqSJVTSwNJNTWlVTn
+nLsMghDbQdnhwWNLjcwNSlVH
+ZZDgnDQvDdndPCmfrRqzvFqpmp
+PPzCrcGGlnhPcsdfNZZdpLLNZsfd
+RjjWHjVWDvjWqVMHjHJjVlHdwwJbLfNZdfdgfpppgpfpZw
+lBVvqjQqBDBlVmCFGChhnSmTTrmr
+BZnGZFvGvBGGrwLBZlzNgmzMhMdfmwgmdmmt
+cpDHtVjDWjCtDTCcDNhhzNJszgzMTJhmgg
+VWWcRWDpPDPPtHtScqFrLlBFFFSFBqZLSF
+qBFcCGFcHHGBldzBLtdzSrdR
+fpmfpswfQNQmfPHfPPgJNwRtngTtSTRzdTrLRnSnldLd
+fsHNpNPwQZwhVHMFGqvvMcqWFGVF
+FwFJlqDDwwgFHQdmFmSQ
+pPtzcrLHZrQfdsBsdLdf
+bHrrHjbrjbrJvDvbqMVNqJ
+WVVpPHPfWnHmpccpnpvQcrgNNMSCTMjMgjjMMN
+RsZbhRFTDDJtZFJhTLRRLMrMrCdSNCdSMjrNhjNGSQ
+LLqtqqzwqmmflPTq
+mmLhdZSdqhqnqMZShLQrMWcrcWQwTgrWVVWc
+CCvjjsfJRCCJbDbFsbGJvzgWWGlWrWlwTQrwQGGcHlBg
+NRDbRCNsNjQPSSLZNdLn
+cmVLcQZPSHBGlSddBf
+DFNzDNszlbBlgHNN
+tWRzFjsWWtrtlDztzwjDjThLPhRMpppLMhmMhnmncRcn
+LFFcgdNLpLQggZQMFMcNJggRHCHsTtRtHTzCTZHRsfSRfs
+qnhlhmGrrhhnqdmGhdhWbnSRzSfsBRSTSRtBflRffzfz
+PnbmrmGjWMVNvdPFLp
+swcWsMMmVwWwFtWlbnnZnFBhbNfrhN
+dQLZHjpDQCfBBBBTGTTC
+DJvDpDSzSDQZMWsWwPqVtwcS
+NVTMjjGGNBqhNttdTTjtcqjCfDlhZhSWCFFJmSmZmWJhmZ
+rznsHPnRLzwspZDWfGZJSLZZDC
+QzPRRvRQszQsGQcVNqTBBdVj
+rHGBglBNLpbqCgFC
+PbmbRnmMSbRPDWRnDVSMPMWmvvcvqqppTLZZFpvCpczLcCVv
+dsdMSPtMdPnSffQwGGsBBbQw
+nqjTlGPGnqWsMPPwGdGjQvQvJCCQBvmvCvQJtmCw
+DDhVbDrcVVFZLzHrZBRNCWStmQWztJvtCm
+VHDLhFFDpcHZcHGWfsGlspTTMqps
+FTPZwBzHHFLTTSwHLJTwVQqnDrzgRRVgQpDVRprn
+jJMjsWlvQqVrqgWW
+CjNsjjvlmslbcJmmbtCtCThdwhHLhhhLPdBCSPFh
+jfgllWfLrfmlTjsCjcjDNNDnNcHJnd
+MMBRSRZGppGFpBbbBGvVnFHhcCJqNcNcHCFNgnnn
+pMZZgBRVZVGRtRSMbMbvRQmTswWfzLzLzWLrPQmfwLlW
+tzpdHLNpfpPnlNFHnpssbgShtqcgTTggrsqg
+JZwWGCWMCcbsSHgWjq
+QCmDZCJwmvZvCVCVRQGCDMFBNlfHmfLLzPPfdpfBLlPB
+PCvRTdPPBVBTGgLGrGqMrMnv
+twQwStrsQwstjSHmmpqZpwqNGnGnNnZgLN
+mJScfjbttQjQtjcmfbbQJHFTBfdfRhhrPhhTfPVVhPPB
+DMPJmLLjhJwNBCNBww
+TpccnsZsbTHpsTHVszbpbGHSNwBtWlfrtCtCfrtlBlFZlf
+HsHvccvzbqsGzqnnHvLQPghQNNDDvLLjdjLR
+zmgVMrrjjMGbbzzdqqrgVbRTHqTTThpNHphNTvvvTNnv
+QLSmZmSJTvTnZTvn
+SfDtDDmQCFDwWmSrjPPGfjMjjGfMgV
+hdNHNHjnGHMTcpWlhBchRBJR
+fPztCTPtttLwLzVbwqSVtCBBDpWvlcRRlBpbDBQWcDWJ
+ftrCVzfTCFFzTFPrPjNZFHnNsMdZgjHdss
+TVcTbdqLqzHHRNHM
+PppQTWffPfCPQSsCprzRwRJDzMDzNwRBRPHN
+pjCTZjTjmTtsZhGcGdLvdlgv
+VJRhVfJRBgbdrrrvJpJJ
+cCSSHSHnZPwDFNHCDCQdbQQdvqnMsrpqQnvq
+NFFCwSrDzCNrwhtgzhWtBhgzWB
+RRBRczzcvmfzVRzVPvPTlCWnnlTGqGMgTTnG
+tNLdSdNSMFhsFttddtjlwGqllqQglqTWqwnThT
+rLSsLrNdZbbHjLdSFFMjLLtSfVRJzVJJVZcRfvZVRfDpVvRz
+DBsdssbdbDfPnnqzzJbqStqzjjJS
+RcGMGwwmrJjFFHPG
+mCgwMLPgCPmmwWDBDZvWvBCWfZ
+cJCGJJMZcMGWMhWCJTfFSfDmmgFmtshggffr
+vBVQBDbNstQmFsfm
+RVwHNblzwHvNdvBwNjVHGZJZLJTMLMJDZLGRMDGG
+LNCssCldDbrnNtVWNQ
+mmcpRBMBRBTZzgMMhtFFvrWQrQmWFtvn
+MZTgzMZSzTfSMDHwCfPlLLDnwL
+HlPcjMSHsMSPbgLhFPFNzP
+ZfRhtVdGBNLFzLqf
+DRtGGtRGJJTJDZDGdCJrVJmlWvHWcvjMsMWmhQsmCMjW
+swpQcsBvvHFpBHHcCHJvJddvbbWPdzhzzqqWdhPnhP
+gDDGTgjNWZTMTNjjggRLggldSPqSqGznnhnbdfnbqfhh
+WDMDtDNDctVFJstJ
+rFDbGjrGbpBBbrCbrwpvvZQZZhgTLVVVVLgThCTggg
+NlfHpttqzltMzRSMSdWRNSfSTTmqgcLgQVcQTcmgQgmZVPVZ
+HWSWpMHNpNWlpNMsMzWGGwwBvvwBnwBvsnnvnB
+mZVVHmmRZlvdjvNpHh
+DFBnFDtnFbBMrQbBMvFLvgtjjNpcLpJdNzJJdhWNpJNWcN
+QTsbrQggBsvsgVTwRVGZCfGZfR
+RGNGlGTWJnJlMcRMGqvSmnDtvDDvtLSLvr
+HfsFhPPdVshfbggDVmzcvSwvStVzDq
+BPPfCgCFfcBbPbHbBHZPFsbBpMGlClRNJRlQTjQWjWpTTlGT
+HQNqQbbRQHbZPZQPqbZTvWFWmCjvFRvRTSrRrr
+lBpBpzLLdBwsLwLLWNggzCFTCmFgWmrF
+VwsswGVBfJfccLBcsJGNdpJHZZqnhtqqnhPHDZHVtPQMZn
+LMHnHnPMnFdJFNFJjZvrJF
+wlTlslptlwtzcvTqvTsVSWWrbJfmJZNZJjcNWfNJmf
+qDlqVthTztSSpSlqtpTTzLvRRnnCvRCPLBQGDBdDGD
+HlmlJgRBBpJLpPBHnlLJsrgJDMttvSdddcMSStWjjWtcSzjs
+qfTbNPTVGhGFCVGTwZfNZNNVWvjSczcjStMMcdSczzczvbcW
+GZVqffQTwNQTmPRlggHLprHQ
+BjsWschcTjjWclQTSnZFrjtFtbzZfqntzF
+qggNGMHgvHMRZMtznbrftMCn
+qvHdqpwgJTsVccwscT
+FJwNPHJmPHTJHglTFwgmwqtShBqDmDBzzBzWhCDWqQ
+fpsjNsMVLVjDCCSzBtjztt
+sLrdfbsMcbMRZZZbbsfrsrNgGNglRwllRnJnwFvnFHnG
+lWWVTJlJCTTzDdWzqdtFFt
+PvPvrhbjhgSjvJQSnQRbjZDZFFHMtGGqFtRMGZFtGH
+rhPrSgfvJPfmwsTpLcsV
+
diff --git a/2022/03-rucksack-reorganization/second.zig b/2022/03-rucksack-reorganization/second.zig
new file mode 100644
index 0000000..25375bf
--- /dev/null
+++ b/2022/03-rucksack-reorganization/second.zig
@@ -0,0 +1,43 @@
+const std = @import("std");
+
+const example = @embedFile("example");
+const input = @embedFile("input");
+
+pub fn main() anyerror!void {
+    try std.testing.expectEqual(solve(example), 70);
+    const result = try solve(input);
+    try std.io.getStdOut().writer().print("{}\n", .{result});
+}
+
+fn solve(puzzle: []const u8) !u64 {
+    var it = std.mem.tokenize(u8, puzzle, "\n");
+    var tot: u64 = 0;
+    while (it.next()) |line1| {
+        if (it.next()) |line2| {
+            if (it.next()) |line3| {
+                var i: usize = 0;
+                outer: while (i < line1.len) : (i += 1) {
+                    var j: usize = 0;
+                    while (j < line2.len) : (j += 1) {
+                        if (line1[i] == line2[j]) {
+                            var k: usize = 0;
+                            while (k < line3.len) : (k += 1) {
+                                if (line1[i] == line3[k]) {
+                                    break :outer;
+                                }
+                            }
+                            continue :outer; // char on line1 was not found in line3
+                        }
+                    }
+                    continue :outer; // char on line1 was not found in line2
+                }
+                if (line1[i] <= 'Z') {
+                    tot = tot + line1[i] - 'A' + 27;
+                } else {
+                    tot = tot + line1[i] - 'a' + 1;
+                }
+            }
+        }
+    }
+    return tot;
+}