commit f5cc3bfdb42a459861f2f11e5846c483e93305b3 · dunkirk.sh/aoc-2025

+81 -17
ts/06/index.ts
···

       1
       1
        
       const file = await Bun.file("../../shared/06/input.txt").text();

     

       2
       2
       -
       const problems: string[][] = file

     

       3
       3
       -
       	.trim()

     

       4
       4
       -
       	.split("\n")

     

       5
       5
       -
       	.map((row) => row.split(/\s+/));

     

       2
       2
       +
       const problemsArray: (string | ("*" | "+"))[][] = (() => {

     

       3
       3
       +
       	const rows = file.trimEnd().split("\n");

     

       4
       4
       +
       	const dataRows = rows.slice(0, rows.length - 1); // exclude operator row when detecting split columns

     

       6
       5
        
       

     

       7
       7
       -
       const problemsArray: (number | ("*" | "+"))[][] = [];

     

       8
       8
       -
       

     

       9
       9
       -
       for (let i = 0; i < (problems.at(0)?.length as number); i++) {

     

       10
       10
       -
       	const localArray: (number | ("*" | "+"))[] = [];

     

       11
       11
       -
       

     

       12
       12
       -
       	for (let j = 0; j < problems.length; j++) {

     

       13
       13
       -
       		localArray.push(problems.at(j)?.at(i) as number | ("*" | "+"));

     

       6
       6
       +
       	// 1) Find whitespace columns across all data rows

     

       7
       7
       +
       	const maxLen = Math.max(...dataRows.map((r) => r.length));

     

       8
       8
       +
       	const splitCols: number[] = [];

     

       9
       9
       +
       	for (let i = 0; i < maxLen; i++) {

     

       10
       10
       +
       		let allWS = true;

     

       11
       11
       +
       		for (const row of dataRows) {

     

       12
       12
       +
       			const ch = i < row.length ? row[i] : " "; // virtual pad short rows

     

       13
       13
       +
       			if (ch !== " " && ch !== "\t") {

     

       14
       14
       +
       				allWS = false;

     

       15
       15
       +
       				break;

     

       16
       16
       +
       			}

     

       17
       17
       +
       		}

     

       18
       18
       +
       		if (allWS) splitCols.push(i);

     

       14
       19
        
       	}

     

       15
       20
        
       

     

       16
       16
       -
       	problemsArray.push(localArray);

     

       17
       17
       -
       }

     

       21
       21
       +
       	// 2) Split each row at those columns, including the split whitespace in the left segment

     

       22
       22
       +
       	const cuts = Array.from(new Set(splitCols)).sort((a, b) => a - b);

     

       23
       23
       +
       	const segmentedRows: string[][] = rows.map((row) => {

     

       24
       24
       +
       		const segs: string[] = [];

     

       25
       25
       +
       		let start = 0;

     

       26
       26
       +
       		for (const cut of cuts) {

     

       27
       27
       +
       			const end = Math.min(cut + 1, row.length); // keep the whitespace column with the left segment

     

       28
       28
       +
       			segs.push(row.slice(start, end));

     

       29
       29
       +
       			start = end;

     

       30
       30
       +
       		}

     

       31
       31
       +
       		segs.push(row.slice(start)); // remainder

     

       32
       32
       +
       		return segs;

     

       33
       33
       +
       	});

     

       34
       34
       +
       

     

       35
       35
       +
       	// 3) Transpose rows -> columns

     

       36
       36
       +
       	return segmentedRows.reduce<(string | ("*" | "+"))[][]>((cols, row) => {

     

       37
       37
       +
       		row.forEach((cell, i) => {

     

       38
       38
       +
       			(cols[i] ??= []).push(cell as string | ("*" | "+"));

     

       39
       39
       +
       		});

     

       40
       40
       +
       		return cols;

     

       41
       41
       +
       	}, []);

     

       42
       42
       +
       })();

     

       18
       43
        
       

     

       19
       44
        
       (() => {

     

       20
       45
        
       	let total = 0;

     

       21
       46
        
       	problemsArray.forEach((problem) => {

     

       22
       22
       -
       		const operator = problem.pop() as "*" | "+";

     

       47
       47
       +
       		const localProblem = [...problem];

     

       48
       48
       +
       		const operator = localProblem.pop()?.trim() as "*" | "+";

     

       23
       49
        
       

     

       24
       24
       -
       		const nums = problem.map((val) => Number.parseInt(val as string, 10));

     

       50
       50
       +
       		const nums = localProblem.map((val) =>

     

       51
       51
       +
       			Number.parseInt(val.trim() as string, 10),

     

       52
       52
       +
       		);

     

       25
       53
        
       

     

       26
       26
       -
       		total += nums.reduce((acc, curr) =>

     

       54
       54
       +
       		const value = nums.reduce((acc, curr) =>

     

       27
       55
        
       			operator === "*" ? acc * curr : acc + curr,

     

       28
       56
        
       		);

     

       57
       57
       +
       

     

       58
       58
       +
       		total += value;

     

       29
       59
        
       	});

     

       30
       60
        
       

     

       31
       61
        
       	// Part 1

     
···

       33
       63
        
       })();

     

       34
       64
        
       

     

       35
       65
        
       (() => {

     

       66
       66
       +
       	let total = 0;

     

       67
       67
       +
       	problemsArray.forEach((problem) => {

     

       68
       68
       +
       		const localProblem = [...problem];

     

       69
       69
       +
       		const operator = localProblem.pop()?.trim() as "*" | "+";

     

       70
       70
       +
       

     

       71
       71
       +
       		const maxWidth = localProblem.reduce((m, s) => Math.max(m, s.length), 0);

     

       72
       72
       +
       

     

       73
       73
       +
       		const cephNums: number[] = [];

     

       74
       74
       +
       		for (let colR = 0; colR <= maxWidth; colR++) {

     

       75
       75
       +
       			let digits = "";

     

       76
       76
       +
       

     

       77
       77
       +
       			for (let r = 0; r < localProblem.length; r++) {

     

       78
       78
       +
       				const s = localProblem[r] as string;

     

       79
       79
       +
       				const idx = maxWidth - colR;

     

       80
       80
       +
       

     

       81
       81
       +
       				if (idx <= s.length - 1) {

     

       82
       82
       +
       					const ch = s[idx];

     

       83
       83
       +
       					if (ch !== " ") digits += ch;

     

       84
       84
       +
       				}

     

       85
       85
       +
       			}

     

       86
       86
       +
       

     

       87
       87
       +
       			if (digits.length > 0) {

     

       88
       88
       +
       				cephNums.push(Number.parseInt(digits, 10));

     

       89
       89
       +
       			}

     

       90
       90
       +
       		}

     

       91
       91
       +
       

     

       92
       92
       +
       		const value =

     

       93
       93
       +
       			operator === "*"

     

       94
       94
       +
       				? cephNums.reduce((p, n) => p * n, 1)

     

       95
       95
       +
       				: cephNums.reduce((p, n) => p + n, 0);

     

       96
       96
       +
       

     

       97
       97
       +
       		total += value;

     

       98
       98
       +
       	});

     

       99
       99
       +
       

     

       36
       100
        
       	// Part 2

     

       37
       37
       -
       	console.log("part 2:", 0);

     

       101
       101
       +
       	console.log("part 2:", total);

     

       38
       102
        
       })();