Merge branch '2022-04'

2022/01/main.js

@@ -0,0 +1,11 @@
+import { expect } from "vitest";
+
+export const spy = (x) => {
+  console.debug(x);
+  return x;
+};
+
+export function expectSolution(result) {
+  console.info(result);
+  return expect(result);
+}

2022/01/test.js

@@ -1,16 +1,14 @@
 import * as R from "remeda";
 import { test, expect } from "vitest";
 import fs from "fs-extra";
+import path from 'path';
+import { expectSolution } from './main.js';
 
 const split = (splitter) => (text) => text.split(splitter);
 const sum = R.sumBy(R.identity);
-const spy = (x) => {
-  console.debug(x);
-  return x;
-};
 
 const input = R.pipe(
-  fs.readFileSync("input", "utf8"),
+  fs.readFileSync( path.join( path.dirname(import.meta.url), "input").replace('file:',''), "utf8"),
   split("\n\n"),
   R.map((x) =>
     split("\n")(x)
@@ -20,10 +18,6 @@ const input = R.pipe(
   R.map(sum)
 );
 
-function expectSolution(result) {
-  console.info(result);
-  return expect(result);
-}
 
 test("part 1", () => {
   const maxCalories = R.pipe(input, (calories) => Math.max(...calories));

2022/02/part1.js

@@ -0,0 +1,60 @@
+import * as R from "remeda";
+import fs from "fs-extra";
+import path from "path";
+
+export const sampleInput = `A Y
+B X
+C Z`;
+
+export const puzzleInput = fs.readFileSync(
+  path.join(path.dirname(import.meta.url), "input").replace("file:", ""),
+  "utf8"
+);
+
+const playMap = {
+  X: "A", // rock
+  Y: "B", // paper
+  Z: "C", // scissors
+};
+
+export const parseInput = R.createPipe(
+  (text) => text.split("\n"),
+  R.filter(R.identity), // remove last line
+  R.map((entry) => entry.split(" "))
+);
+
+export const movePositions = ["A", "B", "C"];
+
+const playScore = {
+  A: 1,
+  B: 2,
+  C: 3,
+};
+
+const draw = 3;
+const lost = 0;
+const win = 6;
+
+const outcome = (opponent, me) => {
+  if (opponent === me) return draw;
+  if (opponent === "A") {
+    return me === "C" ? lost : win;
+  }
+  if (opponent === "B") {
+    return me === "A" ? lost : win;
+  }
+  return me === "B" ? lost : win;
+};
+
+export const mapScores = ([opponent, me]) => [
+  outcome(opponent, me),
+  playScore[me],
+];
+
+export const solutionPart1 = R.createPipe(
+  parseInput,
+  R.map(([a, b]) => [a, playMap[b]]),
+  R.map(mapScores),
+  R.map(R.sumBy(R.identity)),
+  R.sumBy(R.identity)
+);

2022/02/part2.js

@@ -0,0 +1,25 @@
+import * as R from "remeda";
+
+import { movePositions, mapScores, playMap, parseInput } from "./part1.js";
+
+function calculateMove(opponent, verdict) {
+  const incr = {
+    Y: 0,
+    X: 2,
+    Z: 1,
+  };
+
+  const index =
+    (movePositions.findIndex((x) => x === opponent) + incr[verdict]) %
+    movePositions.length;
+
+  return movePositions[index];
+}
+
+export const solutionPart2 = R.createPipe(
+  parseInput,
+  R.map(([a, b]) => [a, calculateMove(a, b)]),
+  R.map(mapScores),
+  R.map(R.sumBy(R.identity)),
+  R.sumBy(R.identity)
+);

2022/02/test.js

@@ -0,0 +1,41 @@
+import { test, expect, describe } from "vitest";
+
+import { expectSolution } from "../01/main.js";
+import {
+  parseInput,
+  sampleInput,
+  puzzleInput,
+  mapScores,
+  solutionPart1,
+} from "./part1.js";
+import { solutionPart2 } from "./part2.js";
+
+describe("part 1", () => {
+  test("input parsing", () => {
+    expect(parseInput(sampleInput)).toEqual([
+      ["A", "Y"],
+      ["B", "X"],
+      ["C", "Z"],
+    ]);
+  });
+
+  test("mapScore", () => {
+    expect(mapScores(["A", "B"])).toEqual([6, 2]);
+    expect(mapScores(["B", "A"])).toEqual([0, 1]);
+    expect(mapScores(["C", "C"])).toEqual([3, 3]);
+  });
+
+  test("part 1, sample", () => {
+    expect(solutionPart1(sampleInput)).toEqual(15);
+  });
+
+  test("solution", () => {
+    expectSolution(solutionPart1(puzzleInput)).toEqual(12458);
+  });
+});
+
+describe("part 2", () => {
+  test("part 2", () => {
+    expectSolution(solutionPart2(puzzleInput)).toEqual(12683);
+  });
+});

2022/03/input

@@ -0,0 +1,300 @@
+fzmmmfwDWFzlQQqjCQjDGnqq
+tJHJvLJVVttNsvTtTvgHHSVwCsQRQQZCZZMqQMQBnqBMQs
+LgThNJhNSgTJVgvgtghPhbpfWzfbwfPmpprb
+lDLnSnLZRjmWrlhrFF
+PffQJNqJbPZbpmjrrCVNFmCh
+qzbcbqfMfZMTfQTqqzzTPPLMHgBBBtHRStvgHRDBnSRL
+WPZfJlZZCMwwZPWCwWzVHQhsshVSsfNQHdvQNN
+FLGDGGnGdVjQQQDQ
+ccFFbggLnRcLFRtFBmnJzdZZzZBMpwJlZMppMp
+RZsnCZssCnDccJCnfcQfHTdzMzhdLdMTqdRqpRLwqq
+tNrGNrrvGhTThQqw
+rrFStPgrFWWgvmPgQjtmNtmJcfJcsJsZblDZfbfHDFHnfl
+RdTfgbbPbJWDDqRvsDsmVG
+NSQZLQZHpFGLqnLszrJm
+ZMSNMHhNZMMSQwhQJWPBJCbhbcgtgfcJ
+qZfqPvLnnZGpGpCJlvsMsMlHJJHB
+mTWFFFTTtVSJMzzjWgSH
+RbVdtdFtcrmbRQDDVHDQTbDNwLPLfnqZnhZhQnNwfNqnnn
+nhHfSGHGThhZjnhrrSnsSczdzlfzzdQQVzRNFNcFdl
+JJvCDvmCbtvpvbMmDvLbCJpmqdVVVcMcNGzRcNFcRRzRclQd
+vwDCwtLmwLBDJmCHHjHHWGZHBnsnnj
+QWTMqZhThbTbLwtGBrQfQQNr
+jdzSSccVPPcgcLrDBtDVwCfNNC
+vcBgcmssccplTnnTqsMhWW
+FlcwZhBhGZhFJnGtZZFwlGsWRLHdWqMzPjWRLTLJHHjdWq
+vfmrmbpfpMfzjHjfdM
+VCSmVpmrNDMZhSMcsFnh
+nHqQVtVZGGwwwnSF
+fMBBBWCsCfMMbWfbsGmGzFjQGQFCPhFQhF
+fbcsWpJRsWlcNVLtqtLLQcZQ
+rgNJdfNJpgpJVMMVfmfVJgCtCTqqqzwTqrBsTswcCCss
+lFLHGWLvHQFhnQFhbFnbHWWPBtwqzBPTcsPTswZCPBGCTC
+QQtbRtLhtjgdfMRMDV
+jTRhJpGhQPfPLsDhWh
+wVVMbqbHwVwwMplHWfsfNmWcSLqcLmSs
+lVCZlHnwHdRpRGvZTBGJ
+csppppDDbGLbSqndFHHNdHsH
+lVTlgWgjzCzfgvfggZWWlnHPPBHrSCqBmrSBrHHBnF
+QFgvFfjTvZjzlvVTWljvTtMbLcccbRRMbwLMMLQLbw
+tjhLjLJzpJpwjsqqfQqNrNfRnsRR
+WvwGBPwWZZrnbBNrNnnC
+PDvGVTgvTMGvZTGTPvWDZVJjljtLzhtmLlJjwJVJLm
+WbzpSNswNWszwSLgSNMcrrBfPJJcfsHMrvMv
+CFllhlGFDVFRCmhQDlDTBBcvgBCTcHPHrfrHTJ
+qGRgVFhDDZmDnDqhgQFGqzwtzSjddwZbzwpLNzjpdS
+FlpZrQSJJmQpSpqlQgbbRZCgGCZdDdbNdd
+WswHfjfnhWPFDsFRDcbBbR
+WjHvjjWTfTvHFjzvPnPtttVTTJVLtJSpmtlltp
+tnjrnnnnhNlPBtbbcWpZScpjbZSz
+wmsFqfqqqGHTLbzpLLbgzMcH
+FGJqsmQGRVFwwQJschPdhPrBndBhtPhrQQ
+dRdJRfTnCRNlJjPBDmBJsbBDzm
+wSFWSgGVSLwpFhpLhQjzgPzbtDPDbPBsztrP
+WMGvVMLLBCclNHHRlM
+gfSffQBDBtZvwwpWDHcbwb
+JnCmmJCRmztsVPJRFjFchcGGWFWcGcHFvGLvHF
+VCPzJnsPVCjtPjdMsMdmVmMBfgTZBTMfSfZSSlfNNgSSfg
+lwHJSVZHWWVwJQwbbVVtwWVVdpdPfRfgDLPZLTZLDLgRDTZL
+hhBrBqRcnhsFFfddmdmmCmmppn
+MNNBBRRshNHbtVMzQJMM
+NBsSNtLNTtNsvlTBBRLgFSCbFmbHFCFhgcghSm
+WJWWDdVzDZJjDJQcCDHmmhCnmHmHFm
+zQVdQZQwqVQHjqzWWWdHpzMwGMBlGLLtTvRvRNsMwwNN
+ZCztttSjGSqRZgRPDNQQNr
+hLvmHshLmLcFwwhhwLqMVRRRJQQVNnRJMVRDNNRr
+HFhTpFqqLcssmqmFftblBSjCjStjbGWBfj
+crffjHDfrQfnfpLPgbgP
+TmFvFCmFTFFCtNsmMsRvlRTpPbLGMnGSngPppShGpbdgGJ
+vmslmwTNmtstzFsCvRFrHBrDZzcQnWqcDDHqQB
+LQLPVLGdGrRPRhHgwMhllhhs
+ZbSZTNqSZfNqNCtSSmTttbpSWMlzWlslpWHsWgJWhwJzBMlz
+bqjqqFFjHqTTTZTmSNbfmdrFQnDdcvVDGQDvvVnQnr
+mQdcdsSThlccSWhMgDnQnFtjQPtnjPNvtR
+zzsGwzrrHGBfZJGrJpDtNHFjvNvDvVRvNRtV
+wZBCGrbrszTbThcTcLcb
+gJDDDDcPQgQfNFPhhZGDDcZZSLVtlCqzsMlzqpszlsVtFSql
+bBrdwHTrHWTrTtzLlSMCCCprCq
+dnBwRvmnbmBvTpbnbWbTjZPQJhhchmJcmcQPfmGNcJ
+sjMGBLWGZjsLjJTBCCbvNrBCHC
+mpcRfDSSdqDdlRqdwRvFrHFbrHJFJVvDVrTb
+qvlgqwpcSQSfLjjhzgnMzsnP
+VgmLHHNRNVLNhsNgRHLltjjbCWnCWZbldntW
+GGMFPJqPwJGTvvCCdqdqlqCj
+rGwGrMQzJQBjJwTVHgDQDHcsfhVhVg
+pblwGBlFlWwwlgCSFwbLvQZFvzvZhzvmQTLLzJ
+HfqccHzVDNqLmmPmPPQZ
+MNtrVdDjHtrzGBdbGWCblw
+NNhnnLdnnfhdhVjvThvqVvCj
+tHtHBzBGWHBWGtPBSvvpGZVbSsTFjSqqVbscgjCjqqSC
+HBtzJHzzpDZpzMWpGPtWHvZwQmNLlmQnmNdfMmNRmwmlwd
+QzGqGwmbfTdPBgRRcgmMPC
+NtNZhljrNjrSrtltWlCJCJJfcVVRcJcRgPjf
+NlWSZZWsHhWWlprSSvZWHrWfQLLQbLGfQpQzzTFQbwzQdd
+gcwcSnccnwLRRSzcBQRvZZdvtNtvRbQJQv
+CqrCrrPsVstvbfDfbb
+TPlPVhWFFMGMnMjbcT
+gjjHGvcHgsgbSRQbRFWbjC
+ttnBTNSSfwBLzplWPPdlLlMPlMCQ
+TBZpDtmnnZNvhJDHggqqgS
+zfqzzGwMbllcJFqm
+NpHgpRZrRpSrSZLghlTjchNlNbhFmchb
+RHLWHgLBggZpHpgHRZrLgZLQCMzCfDWGMCzMQQGvPmvvfC
+bBWWlFFBBFdVMLfvsfjrtBvTrr
+qZsgNZzcwfjZrfPf
+gcnNNcDncsDGzggDnNRJnzHhmlMVSSbhVVVmMbbhVmMlGl
+dNNRQszqRhPNfddWltvDltMMNlnncv
+ZjZbpgpSpjpJgpCCpbFlTnSDTlzclDnMvnnMlT
+GCJpjbgzJCpwZwrHZrgHsRBwBVRRsqdqPhLBQqsP
+mnnVCcwGwnsVJntmfnBtBhTDzpzzpDWbDbsLLzpWDz
+FcHQdZSRHbhZZWWhrW
+dNljMlPPHdMPvRlHMRdjRRNBnwJfCVqwqqffCfCwtcBV
+ZGtGzBBGjvdZvLWLcrPVcZcsNVNmVpcH
+MnlgngCJMgJbhfDbCDPrHHVcNNrVpbVpVmmcVq
+lSPhlClftSSBvdGS
+jFhGqVCcPMMdGFqczBltzrtglrsrjBgB
+wWgwvfDZvnpmnHwHTfNpDbtRWbzltRlSrRlbBSbbzt
+fHJvJvvTwwJPhCccgQCM
+BrrrBVgNppDVBbTgDvqWdWZqWqwNmNNHvH
+sHsHnHlcJjFwMMFFvGdPvv
+HllCQCJQJsnjgtVTbBgpQrSr
+JgLPLwbhBrCbLBCJPFFlPFZRTNTZFRqlRq
+pmffSWvDcfSfGmvsNHZsTRsWllssbT
+vDddMmScdStfzGcpzzwhJwJwnCbLwwLLCwht
+sWSSvmsZsdZPWdLPRRsmSrrnlnvJjfnggfrgtfjnjr
+VWWWBhhHBBHtljMMfJHrrt
+WWqpWVqQqLNGRNZP
+QHjjGVBQpffpjqppQsSsQHWJcVVgJFWcFTWgNLggFPNc
+bzzmbzzZnZztFTNJWRqmqcgJ
+zDZlqMtbwhCBBfppvHDGvf
+BNTdfWJmzHNHHzzTdLCfCfCswQjRjljVsh
+FbGnrFnrPGSSvGPFZFFPGClLQpjQRwLjLplQhRlsrQ
+GbnvvgvPFwbwcnZMMGSFvFHdNHmTBNJNmmmDTJDBmWcT
+rBhRPrjJrRtTHtWHWcjc
+SDdGqmhdFSqblLGlHHfHWl
+DSSmFqhsFqFdzqFgwsVnvBQPPQPQVrnRsJMR
+NZcgQdmSwZgdPFPVNFPqqVVF
+hlhhjMhGjLhLDGDhCBJDCrRFRrqqpLPfpfPRVPprPm
+MlhjlMDDJTCmZddQQSTcTT
+zRddrwzwNhrzrtCLtLfsLrqflC
+MbSDZvVwGZpJwvHvBVfsqtjqlsPPfsqsfclb
+vJpvJvZTVgTdTgwdTn
+SZMsTTScDMqwtDDJ
+VWrbzFvnrvFQQtnhzdPFmfwGfqmGPfDwmfPJ
+rrLbrnVrLvVQpLHSHjsTBBjZBt
+bSrpbWpPpfzPRWrWvhJgddrcccgFnFss
+ljGNTCtMNLGQjNMjQMGtZJDDggcldcFcvhdFddnhhF
+vNCmQMjmvGzpRPPzzmfw
+BrbdcqcdSZRLQltNDqFpCpHH
+jnTzWsWjWjwTQnzMvFlCzNDhNhDCFGpHpH
+wmmvjVQMvwmsQMMwnsTPgVfgJcLcgfSbbBdBbJSdbSBS
+bJFbMdcmgFSFgmggJFcGwjRdzPWZWGDDGGRwGD
+hrttffCVVCTVlrttQwzRzwWTqRGDGwjTvG
+rfLChHhlpHrfHlnWlpWCpQVcMSmMmSJMmggbmMSMLFNSSs
+JRMBJfMJQJTcNNdD
+LHsLmspghmmpdwwwcwRCpPTT
+ttLLlRSlqjrMqFtZ
+VjtHVHtvVqttCdnGpHtplcshglNgprrlMhrcNghw
+WTWRvRWFZQLWDvDWzwscNfcflcshlshFlw
+WQmBQWPTVGnJPnvn
+cpRwjcQwVfQzQPQl
+BZgGDBZBsgWBDDJzlhfhJVmzVfmThm
+FqWDDGrGDFNqFrDZFnplNHnSwtnSRwRplN
+VMLVRhRLRfhfgGdfVdZWRdTHNqHCDTrSJNBBBgJNQgND
+swlcpsFPcPwzpSlTTDrNrQPQqQBBrH
+zsppFscsscmbzsFsbsZbMfRZdVdVMbVSWhLG
+NjcjHFjrHHFpjGtVtGWVZW
+fwPlsJqdndPnwJfQdfllwNtWGdtWMMbtbmbGWbMWGN
+CPlwnCwnwqClTJThTDzzFcHNSShrRh
+llqlsNsPNTpDNTDNNf
+cnvcWFjSrMSFnvWHTzTggHCcllzLpg
+wjJSSrFrrMMJGrFFFGjGvJnFswsRwRdmBdZbbqqsPtQqPZls
+jlclpqjcRqpjzjnVPgTmBmjCrC
+vGvsFNGGMZNvdGshQNJvJgbVMrnbrHVBgBTTbBBPBT
+SvJNGhvvvFdfQvFshSpqPqLzRRPctRcLWwlf
+LWSSqLVBbNqqLrWHLSHzWbbqQfFgZtmtJCQZzgtCFCQCCnJQ
+PlldGDGdjGsMPhssjPmQZFJQQZQghChZQJgv
+jwMcMpsPRRdsRjPwNpTWBLSBqVqTNJWT
+hWnMWgTffWFbMLfHnFMNfHgjtBSNRzjBBSzSBBcStdzBtz
+VGrVCGcVJswvPqJQjtQppBzpSwdjpt
+ZqqsCrmmsfmWcHhngg
+vnNnssMcZnlnlMFMsnFcZMGqJCbLbNLNqgLbgLNTCpLgwC
+hmjzBzHmRSfBfmqgQwpQQJbQJmwT
+WVVtthRtRdsdqtddZd
+LhZBLfZpmcsFpFzm
+vTRRwTRRPnCTwlFgmsczzLmgLvFs
+HVVVNCPPHTTtClRVNSnwLTHSQHBMMHrHWBhrQbJhWMMbZbJZ
+WPTnnDPjvPlChhJPcgCC
+DRQdBqsDQHQLHsBSmVLBcbwgCClbgCGlJghgmhgw
+dHMHQDVVRBsMWTNfWfzWzf
+PlgFPFFJGgJhhMGZwGbpBtQjjjStBttptlSb
+TTcDzmHvdvnDDzdTVnTDmSspWspQLpWmSsmqppsWtb
+CHVdcHvdbrwJCMPRGJwP
+BtBfcPfBhBGDhwHMlCmrNSCM
+dQdzLFTQnRnQVvgLnNlrCCpFrJCNrHJrwm
+zRVLZQRRvQGbwtWfbGZb
+PPcWcwMmCwwgnphCCLpjHp
+TtZsJTzzJSSSZJsdJtTrpblhRlHHHMngpLnnjHps
+ZDrvdFZtJqtStrZfMcGDVwfwffmWmP
+wCwSzzsHChhMVMhCPsSVLFWcdcWGPccRdjFdJjDR
+wBTTlBfgTlfpQQltmfgGGctRdGJJJFDJDDWdDt
+TppwnmlnQQqnlpqlmmwqlpphHqrVrZZSzshzShqzsrZVqs
+CCqCTgmdMCCCMMsWgqqnTCmJDGJcGGJfrGNGrSrrQpwFFSwG
+vZbDZvhDbzHzwNzwNGFNpNGc
+ZjBRVHPRtRLjLMWsCDlmgMdBmW
+MMsstRChwbChqRBqDrJNpNDsHdlNlJdr
+vLmPLfGGGGcTmFfTSgvPCvpZQlHHZpdrFJplQdZHQdHH
+GgPLmvGVSPfmfcfgBtjwCRwwjBbtVWbh
+LPPgFPccLPRswfsHfJgDsH
+bpbpTnCCrnmCtjBnTfDshHDwQVTwsDhQ
+BbrjnjnWCbBWZbPWzLDzDWdNlMWS
+pnncvLbcppBHgBRpddGd
+MtJfjVMtMmFJDjWSjVWzGdGgNQRBzBGNBMCGNB
+ZdDdsJFdDmtJmLTbwcvcbcnwZv
+FGsfFdNdhfbDdbhbLMhbNNTPJVCCZTLJnCRVJLPCRTVR
+qHjsczptHpmgHZBBVVTrrPzrBP
+lmpSlcglQtqWtcWjpQQfWsGDMhGFwdbGGNWhDv
+hNNNjMFMwthjFfvZBjFFvNSdnzSGGdGmHzHgGWSfHWSR
+ppJpcCVslpQJpJJDWHCHmRHHWWGSDn
+QbsrJQTQJVJNMNnZTZNZvZ
+NmRNLtGNmfcRrtDtrJCnWHJD
+blSzzSBssgfslWCCCJWFWHrsZF
+zTzbPBhMlTVSzMlMldlgMvvvvMLGcQRmqLLfvRwQ
+nnZsfsPLLfZfHLWdsZWZHdmcSpTcGmNScJTRGsTJmNcF
+gqVqDMgBlDbwwCqVbQFpTNFcTRSJNSrqqTSm
+jlMVMjljQBjMwhLfWWzhhfhZtmLH
+bfHwMvzwFBNpRjfZ
+nddcVJpGVpGqPVBBFBmhBhmsNRJs
+DWcPgPcPgnqCPlWWVWGMwbzwvQSSLbvgLpHHMz
+NMVqtdPVHgVlrfVrpnjCwNjjpCpNNpCb
+zhSvfWWzRfRLfvSpQjwbmmmvQvwwCD
+LBRRTRcLJSgqqMJlVVft
+GpgNzzSMGpGTrgzgMzJTrPgzjRwBdBlBbLRBjdBwVbLRVbSR
+sQWCfQcflhtQQcWCmsmlsbLnRdwqqBmmbBVbLVLwnB
+fCtQWFWDZFCQhCctFDsftNpzPPzZJpgJJNTgNlPZgH
+DqLtMSDLLttjdDSRdjZtdpdqVWFslFWrqWPqhwhfFwwCFw
+CvTbNvvTJNGHnVJwPfwFFFwsrh
+cQBzGBHnTQGgcNtdMMBpDBtCdtLL
+QsNDfdDNQsSTtrQZQtJJZC
+lLvRWMVMLzWbRjvVgVVGvmTtCrZBrTFFbmJCmsBCrr
+lljvlgpMGgRpsjsRlGGsMdqDdpDqNqfhqqSdncpqdP
+sVSJVmmtmsCCwschrbNMbcBs
+ZgLLfqvzzqgfdqHQLnTLfQQFhFMrhbNGBwgGbMlNcFclwN
+LTzqZrHHQvjLHnHdQTdTQvZQJjCpCJDPmCRRtCpStRRmVtmm
+ccQVcVHwnnDqNqSWNnVvqwcgJblgRslgmdGlssmGbQdddb
+rpFtPrzrMFZvZTLPpglhdssFshssJhsggG
+pTtLtBMjZLfHvNWqcBHf
+PZnSjnnsVfjfLLff
+crvccpglrtHfNbzbHLzmGN
+lptTLFFpdgvttFWltTclplDvhJMSMPhJPhChShPBZBMJhPMT
+mPSPdnhznPdhSmPGchJdFDtBhghgFgWpFBQhTBMg
+rHNNvbqHHHwZwMGMWtgtQMZQFQ
+wRqqRffvvNHwrHqrNqLvCrqvmPnzdsGJsSsSdSsLPVVPnjsn
+CzlngWpClJlzRJpDnpmzCndrhBcrhwcsBcLsNcsmLdQQ
+qqSjqFGTFbPFSPTVjcBcBsDdQrwBVLrNcc
+PtDDtZTvGDvFCMzZlRJCfWfJ
+vtQDpvpvVvvcSFrrljZZsVjFrV
+RqcTTRddRrlsjZrwrT
+zmbdRdMmMgbPDcGhGmnDpcQn
+gZqJRZRZdltFVGZQDZwV
+MCMSRHCMRHBBVtVCGwDCFGtD
+jcHsTMBNSSrBMjmMrcTMpRqpJggllnprqzRPzdlP
+mWSWHdmHWZWjBnGs
+TvchwtTfcTvhzwVGNtdrbjnnBnsnNr
+JTdwghvMzwfdcMVJqPmQFRPpCDJRJFFC
+DsHDCrszvvhHsshvsrrsgwdPpdLFgWLpbRpWFfMjWjWF
+BVJPJmPmGZVnfbVfMWpdLMWb
+cNGtnttqmJHNvNzDPPHN
+gpjmMQMrfmMntCSCNmSNCm
+vDRqphDhzHSdtqdCNH
+LFLLcbJRJLppFQlpMFfF
+SnSdvchzZZczndNvwcwnQrGfqrTTfhhTDgRGGLQQ
+lVWHWMmWmttsFBMLLqLTRRRqqDBGTf
+bsFPbFFssmFjWRmjVFjHbczvpZCwvwZccndpvzpzCP
+jzngbHrlHQllcbcTCtHGWtftGCHqWC
+JJgmsJRwFqChLGtqGs
+SmJmSmDdSPRwSMppJdPPwVvvzNQvjrNMNjMZZrQgZNgQ
+PvPlPcZPZFllzNzCDdhhdHjrpHNjHBHB
+VmgWtJWrqbQmqGDBdGQjjhBGdG
+tmbgggbgnMWnStttgnfnTzrCfPvFnccnPclT
+RQQbdSRdpprQSNVqqqfrffjvnjnJnhnVvHhBhVjJtjJz
+WGgGgLmLgGZMPDBhDJDHjMBFnD
+WPPwPGwlLgZwmWlslCLRNbrsTrfRrNNQqsspBT
+dNNpHpchLppdccTNtZZTRRPSSnwPPSbSnhhrhnSJ
+qfqsFsqffgQMznJrPznbMrrB
+vglfqQCgDgFjglCDCjLZpTHNPHttdcZVVN
+FWtDHDStZwrFCDwrgWPFDsWQJZzlMdpZzlNpNjdjjQzNzj
+BqnVGVcbTmGfHLGVzvpQpvJvQlflMdJp
+ThRRchnHqLTGbFCCCrrSSFhFCs
+wJrwdZPnJwqPbJPCnjFZdvHtMvsLsTsDtHsHDDqvpH
+RWzNRWjRfgjNMMLvcMcLNt
+WGGRQzzRmRmVQSgwrwJjjCbJhnbShJ
+cjngcvcwbMwWnbMWjbgvnsjPftsqfthqsBtsJJJJBt
+HrGFmDDzpmLTHpDsPfsBNBPfzZNPqN
+DDVmDplDrpGSVSTTHGlpLnPwCRnWcvWCdPbbMvcVdW
+BVRlBfPBffWswVWQsfwBNNPMFMmmGFZGnWZGtztrzMZMnz
+HqSJchHTHbTgHhGhvmRzFmnFtzRF
+RJqHTpgDLJDSqLJJPNVjsfPwBVsVLlfN
+NDrBlSmrFBlbbJllmtHHwhNNhZztqHVRzQ
+CMTCGLcvvtfCdCcCvCnMTMcTzjHwVZVRLjRRjQjRHRwzwjVH
+dfGdgGMGPggnvfvgbtDtlSJPDSFJPslJ

2022/03/part1.js

@@ -0,0 +1,20 @@
+import * as R from "remeda";
+import fs from "fs-extra";
+import path from "path";
+
+export const readFile = (year, day, file) =>
+  fs.readFileSync(path.join(year, day, file), "utf8");
+
+export const sample = readFile("2022", "03", "sample");
+export const puzzleInput = readFile("2022", "03", "input");
+
+export const solutionPart1 = R.createPipe(
+  (text) => text.split("\n"),
+  R.filter(R.identity),
+  R.map((line) => line.split("")),
+  R.map((line) => [line, line.splice(line.length / 2)]),
+  R.map((line) => R.intersection(...line)),
+  R.map((line) => line[0].charCodeAt(0)),
+  R.map((code) => (code > 96 ? code - 96 : code - 38)),
+  R.sumBy(R.identity)
+);

2022/03/part2.js

@@ -0,0 +1,12 @@
+import * as R from "remeda";
+
+export const solutionPart2 = R.createPipe(
+  (text) => text.split("\n"),
+  R.filter(R.identity),
+  R.map((line) => line.split("")),
+  R.chunk(3),
+  R.map((group) => group.reduce((a, b) => R.intersection(a, b))),
+  R.map((line) => line[0].charCodeAt(0)),
+  R.map((code) => (code > 96 ? code - 96 : code - 38)),
+  R.sumBy(R.identity)
+);

2022/03/sample

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

2022/03/test.js

@@ -0,0 +1,25 @@
+import { test, expect, describe } from "vitest";
+
+import { solutionPart1, sample, puzzleInput } from "./part1.js";
+
+import { solutionPart2 } from "./part2.js";
+
+function expectSolution(result) {
+  console.info(result);
+  return expect(result);
+}
+
+describe("part 1", () => {
+  test("sample", () => {
+    expect(solutionPart1(sample)).toEqual(157);
+  });
+  test("solution", () => {
+    expectSolution(solutionPart1(puzzleInput)).toEqual(8515);
+  });
+});
+
+describe("part 2", () => {
+  test("solution", () => {
+    expectSolution(solutionPart2(puzzleInput)).toEqual(2434);
+  });
+});

2022/04/part1.js

@@ -0,0 +1,20 @@
+import * as R from "remeda";
+
+import { readFile } from "../03/part1.js";
+
+export const sample = readFile("2022", "04", "sample");
+export const puzzleInput = readFile("2022", "04", "input");
+
+const rangeLength = ([a, b]) => b - a + 1;
+
+const isContainedBy = ([a1, a2], [b1, b2]) => a1 >= b1 && a2 <= b2;
+
+export const solutionPart1 = R.createPipe(
+  (text) => text.split("\n"),
+  R.filter(R.identity),
+  R.map((line) =>
+    line.split(",").map((range) => range.split("-").map((x) => parseInt(x)))
+  ),
+  R.map(R.sortBy((x) => rangeLength(x))),
+  R.countBy(([a, b]) => isContainedBy(a, b))
+);

2022/04/part2.js

@@ -0,0 +1,13 @@
+import * as R from "remeda";
+
+const overlapsWith = ([a1, a2], [b1, b2]) => a2 >= b1;
+
+export const solutionPart2 = R.createPipe(
+  (text) => text.split("\n"),
+  R.filter(R.identity),
+  R.map((line) =>
+    line.split(",").map((range) => range.split("-").map((x) => parseInt(x)))
+  ),
+  R.map(R.sortBy(([x]) => x)),
+  R.countBy(([a, b]) => overlapsWith(a, b))
+);

2022/04/puzzle.md

@@ -0,0 +1,75 @@
+## \--- Day 4: Camp Cleanup ---
+
+Space needs to be cleared before the last supplies can be unloaded from the ships, and so several Elves have been assigned the job of cleaning up sections of the camp. Every section has a unique _ID number_, and each Elf is assigned a range of section IDs.
+
+However, as some of the Elves compare their section assignments with each other, they've noticed that many of the assignments _overlap_. To try to quickly find overlaps and reduce duplicated effort, the Elves pair up and make a _big list of the section assignments for each pair_ (your puzzle input).
+
+For example, consider the following list of section assignment pairs:
+
+```
+2-4,6-8
+2-3,4-5
+5-7,7-9
+2-8,3-7
+6-6,4-6
+2-6,4-8
+
+```
+
+For the first few pairs, this list means:
+
+- Within the first pair of Elves, the first Elf was assigned sections `2-4` (sections `2`, `3`, and `4`), while the second Elf was assigned sections `6-8` (sections `6`, `7`, `8`).
+- The Elves in the second pair were each assigned two sections.
+- The Elves in the third pair were each assigned three sections: one got sections `5`, `6`, and `7`, while the other also got `7`, plus `8` and `9`.
+
+This example list uses single-digit section IDs to make it easier to draw; your actual list might contain larger numbers. Visually, these pairs of section assignments look like this:
+
+```
+.234.....  2-4
+.....678.  6-8
+
+.23......  2-3
+...45....  4-5
+
+....567..  5-7
+......789  7-9
+
+.2345678.  2-8
+..34567..  3-7
+
+.....6...  6-6
+...456...  4-6
+
+.23456...  2-6
+...45678.  4-8
+
+```
+
+Some of the pairs have noticed that one of their assignments _fully contains_ the other. For example, `2-8` fully contains `3-7`, and `6-6` is fully contained by `4-6`. In pairs where one assignment fully contains the other, one Elf in the pair would be exclusively cleaning sections their partner will already be cleaning, so these seem like the most in need of reconsideration. In this example, there are `*2*` such pairs.
+
+_In how many assignment pairs does one range fully contain the other?_
+
+Your puzzle answer was `605`.
+
+The first half of this puzzle is complete! It provides one gold star: \*
+
+## \--- Part Two ---
+
+It seems like there is still quite a bit of duplicate work planned. Instead, the Elves would like to know the number of pairs that _overlap at all_.
+
+In the above example, the first two pairs (`2-4,6-8` and `2-3,4-5`) don't overlap, while the remaining four pairs (`5-7,7-9`, `2-8,3-7`, `6-6,4-6`, and `2-6,4-8`) do overlap:
+
+- `5-7,7-9` overlaps in a single section, `7`.
+- `2-8,3-7` overlaps all of the sections `3` through `7`.
+- `6-6,4-6` overlaps in a single section, `6`.
+- `2-6,4-8` overlaps in sections `4`, `5`, and `6`.
+
+So, in this example, the number of overlapping assignment pairs is `*4*`.
+
+_In how many assignment pairs do the ranges overlap?_
+
+Answer:
+
+Although it hasn't changed, you can still [get your puzzle input](4/input).
+
+You can also [Shareon [Twitter](https://twitter.com/intent/tweet?text=I%27ve+completed+Part+One+of+%22Camp+Cleanup%22+%2D+Day+4+%2D+Advent+of+Code+2022&url=https%3A%2F%2Fadventofcode%2Ecom%2F2022%2Fday%2F4&related=ericwastl&hashtags=AdventOfCode) [Mastodon](<javascript:void(0);>)] this puzzle.

2022/04/sample

@@ -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/04/test.js

@@ -0,0 +1,23 @@
+import { test, describe } from "vitest";
+
+import { expectSolution } from "../01/main.js";
+import { solutionPart1, puzzleInput, sample } from "./part1.js";
+import { solutionPart2 } from "./part2.js";
+
+describe("part 1", () => {
+  test("sample", () => {
+    expectSolution(solutionPart1(sample)).toEqual(2);
+  });
+  test("solution", () => {
+    expectSolution(solutionPart1(puzzleInput)).toEqual(605);
+  });
+});
+
+describe("part 2", () => {
+  test("sample", () => {
+    expectSolution(solutionPart2(sample)).toEqual(4);
+  });
+  test("solution", () => {
+    expectSolution(solutionPart2(puzzleInput)).toEqual(914);
+  });
+});

2022/template/part1.js

@@ -0,0 +1 @@
+import * as R from "remeda";

2022/template/part2.js

@@ -0,0 +1,2 @@
+import * as R from "remeda";
+

2022/template/test.js

@@ -0,0 +1,20 @@
+import { test, expect, describe } from "vitest";
+
+import { expectSolution } from "../01/main.js";
+import {
+  solutionPart1,
+    puzzleInput,
+} from "./part1.js";
+import { solutionPart2 } from "./part2.js";
+
+describe("part 1", () => {
+  test.todo("solution", () => {
+    expectSolution(solutionPart1(puzzleInput)).toEqual('TODO');
+  });
+});
+
+describe("part 2", () => {
+  test.todo("solution", () => {
+    expectSolution(solutionPart2(puzzleInput)).toEqual('TODO');
+  });
+});