Student | Fullstack Developer | INFP
![export function solve(input: string) {
const [towelsInput, designsInput] = input.split("\n\n");
const towels = towelsInput.split(", ");
const designs = designsInput.split("\n");
function check(design: string) {
const dp = Array<boolean>(design.length + 1).fill(false);
dp[0] = true;
for (let i = 0; i < design.length; i++) {
if (dp[i]) {
for (const t of towels) {
if (design.startsWith(t, i)) dp[i + t.length] = true;
}
}
}
return dp[design.length];
}
return designs.reduce((acc, cur) => check(cur) ? acc + 1 : acc, 0);
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:croyym7fbzpi7af4ej2nlv7a/bafkreihwffp2r2f27yf424vrpfxgttslfeih3uskct32tbz77j7dysdohm)
![import { findPositions } from "jsr:@kiritaniayaka/surprise@0.5.0";
findPositions([1, 2, 3, 4, 5, 6, 7], 5); // [4]
findPositions([1, 2, 3, [4, 5, 6], 7], 5); // [3, 1]
findPositions([1, [2, 3, [4, 5, 6]], 7], 5); // [1, 2, 1]](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:croyym7fbzpi7af4ej2nlv7a/bafkreigq4mlykoeaxhxphadpvqoxuymdn675uoyuqm7ssyoyfbvkykzzfa)
![export function solve(input: string): number {
type QueueItem = { x: number; y: number; steps: number };
const size = 71;
const bytes = 1024;
const directions = [[1, 0], [-1, 0], [0, 1], [0, -1]] as const;
const positions = input.trim().split("\n").map((line) =>
line.split(",").map(Number)
);
const map: boolean[][] = Array.from(
{ length: size },
() => Array(size).fill(false),
);
const inMap = (x: number, y: number) => x >= 0 && y >= 0 && x < size && y < size;
for (let i = 0; i < bytes && i < positions.length; i++) {
const [x, y] = positions[i];
map[x][y] = true;
}
const visited: boolean[][] = Array.from(
{ length: size },
() => Array(size).fill(false),
);
visited[0][0] = true;
const queue: QueueItem[] = [{ x: 0, y: 0, steps: 0 }];
while (queue.length) {
const { x, y, steps } = queue.shift()!;
if (x === size - 1 && y === size - 1) return steps;
for (const [dx, dy] of directions) {
const nx = x + dx;
const ny = y + dy;
if (inMap(nx, ny) && !map[nx][ny] && !visited[nx][ny]) {
visited[nx][ny] = true;
queue.push({ x: nx, y: ny, steps: steps + 1 });
}
}
}
return -1;
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:croyym7fbzpi7af4ej2nlv7a/bafkreiewxpi2z2q66y4z427fshf4oytwxsuzbx64nqz3lhg6f4rqqvprza)
![import { findPositions } from "jsr:@kiritaniayaka/surprise@0.4.0/array";
import { BinaryHeap } from "jsr:@std/data-structures@1.0.4/binary-heap";
type QueueElement = [number, number, number, Direction];
const DIRECTIONS = ["E", "S", "W", "N"] as const;
type Direction = typeof DIRECTIONS[number];
const MOVES = {
"E": [0, 1],
"S": [1, 0],
"W": [0, -1],
"N": [-1, 0],
};
export function solve(input: string): number {
const map = input.split("\n").map((line) => line.split(""));
const [[startX, startY]] = findPositions(map, "S");
const [[endX, endY]] = findPositions(map, "E");
const pq = new BinaryHeap<QueueElement>((a, b) => a[0] - b[0]);
pq.push([0, startX, startY, "E"]);
const visited = new Set<string>();
while (pq.length) {
const [cost, x, y, dir] = pq.pop()!;
const state = `${x},${y},${dir}`;
if (visited.has(state)) continue;
visited.add(state);
if (x === endX && y === endY) return cost;
const [dx, dy] = MOVES[dir];
const newX = x + dx;
const newY = y + dy;
if (map[newX][newY] !== "#") pq.push([cost + 1, newX, newY, dir]);
const dirIndex = DIRECTIONS.indexOf(dir);
pq.push([cost + 1000, x, y, DIRECTIONS[(dirIndex + 1) % 4]]);
pq.push([cost + 1000, x, y, DIRECTIONS[(dirIndex + 3) % 4]]);
}
return -1;
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:croyym7fbzpi7af4ej2nlv7a/bafkreiccar4setnbjiorwkzxsni5zf2srrnjup3plipel5occy363fvlcu)
![export function solve(input: string) {
const DIRECTIONS = {
"<": [0, -1],
">": [0, 1],
"^": [-1, 0],
"v": [1, 0],
} as const;
type Move = keyof typeof DIRECTIONS;
const [mapInput, movesInput] = input.split("\n\n");
const map = mapInput.split("\n").map((line) => line.split(""));
const moves = movesInput.split("\n").flatMap((l) => l.split("")) as Move[];
let x = map.findIndex((line) => line.includes("@"));
let y = map[x].indexOf("@");
function move(
x: number,
y: number,
[dx, dy]: readonly [number, number],
): boolean {
const newX = x + dx, newY = y + dy;
const object = map[x][y];
if (map[newX][newY] === "#") return false;
if (map[newX][newY] === "." || move(newX, newY, [dx, dy])) {
map[newX][newY] = object;
map[x][y] = ".";
return true;
}
return false;
}
moves.map((m) => DIRECTIONS[m]).forEach(([dx, dy]) => {
if (move(x, y, [dx, dy])) [x, y] = [x + dx, y + dy];
});
return map.flatMap((r, x) => r.map((o, y) => o === "O" ? 100 * x + y : 0))
.reduce((a, b) => a + b);
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:croyym7fbzpi7af4ej2nlv7a/bafkreia5bwjc7dikqy6o26bdh6vkbynfm5gcwwqzaqcohpkdbaxztxbn64)
![export function solve(input: string) {
const numbersIn = (str: string) =>
str.matchAll(/-?\d+(?:\.\d+)?/g).map((r) => parseFloat(r[0])).toArray();
const SIZE_X = 101, SIZE_Y = 103, SECONDS = 100;
const normalizePosition = (p: number, axis: "x" | "y") => {
const SIZE = axis === "x" ? SIZE_X : SIZE_Y;
while (p < 0) p += SIZE;
return p % SIZE;
};
return input.split("\n").map((l) => numbersIn(l)).map(
(robot) => [
normalizePosition(robot[0] + robot[2] * SECONDS, "x"),
normalizePosition(robot[1] + robot[3] * SECONDS, "y"),
robot[2],
robot[3],
],
).reduce((acc, [x, y]) => {
if (x === SIZE_X >> 1 || y === SIZE_Y >> 1) return acc;
acc[+(y > SIZE_Y >> 1) << 1 | +(x > SIZE_X >> 1)]++;
return acc;
}, Array<number>(4).fill(0)).reduce((a, b) => a * b);
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:croyym7fbzpi7af4ej2nlv7a/bafkreieqli7af2pfz2qlgo3uzuhpk6ymyu35etnmbwips4a6md24bcbk2u)
![export function solve(input: string) {
const result = input.matchAll(
/Button (?:A|B): X\+(\d+), Y\+(\d+)\nButton (?:A|B): X\+(\d+), Y\+(\d+)\nPrize: X=(\d+), Y=(\d+)/g,
);
const OFFSET = 10000000000000;
function play(
ax: number,
ay: number,
bx: number,
by: number,
px: number,
py: number,
) {
if ([ax, ay, bx, by].some((v) => v === 0)) return 0;
[px, py] = [px + OFFSET, py + OFFSET];
const tb = Math.floor((ay * px - ax * py) / (ay * bx - ax * by));
const ta = Math.floor((px - bx * tb) / ax);
return ax * ta + bx * tb === px && ay * ta + by * tb === py
? ta * 3 + tb
: 0;
}
return result.reduce((acc, cur) => {
const nums = cur.filter((_, i) => i > 0).map(Number);
return acc + play(nums[0], nums[1], nums[2], nums[3], nums[4], nums[5]);
}, 0);
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:croyym7fbzpi7af4ej2nlv7a/bafkreibvnbz47l2l6nywwe2xraaaceyvsqjc4soccxvg4yns7d2yidtl2q)
![export function solve(input: string) {
const map = input.split("\n").map((line) => line.split(""));
const visited = Array.from(
{ length: map.length },
() => Array(map[0].length).fill(false),
);
const directions = [[0, 1], [-1, 0], [0, -1], [1, 0]] as const;
const inMap = (x: number, y: number) =>
x >= 0 && x < map.length && y >= 0 && y < map[0].length;
function dfs(x: number, y: number, type: string): number {
const stack: [number, number][] = [[x, y]];
let area = 0;
let perimeter = 0;
while (stack.length) {
const [curX, curY] = stack.pop()!;
if (visited[curX][curY]) continue;
visited[curX][curY] = true;
area++;
for (const [dx, dy] of directions) {
const newX = curX + dx;
const newY = curY + dy;
if (!inMap(newX, newY) || map[newX][newY] !== type) perimeter++;
else if (!visited[newX][newY]) stack.push([newX, newY]);
}
}
return area * perimeter;
}
return map
.flatMap((r, x) => r.map((c, y) => visited[x][y] ? 0 : dfs(x, y, c)))
.reduce((acc, cur) => acc + cur);
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:croyym7fbzpi7af4ej2nlv7a/bafkreierzybns7sdg2wmw7vpokyz4tb7dpwemctfaawmcg2gmycp4idwve)
![export function resolve(input: string, times = 25) {
let nums = input.split(" ").map((n) => +n);
function split(num: number): [number, number] {
const str = `${num}`;
return [+str.substring(0, str.length / 2), +str.substring(str.length / 2)];
}
function blink(nums: number[]) {
const result: number[] = [];
for (let i = 0; i < nums.length; i++) {
if (nums[i] === 0) result.push(1);
else if (`${nums[i]}`.length % 2 === 0) result.push(...split(nums[i]));
else result.push(nums[i] * 2024);
}
return result;
}
for (let i = 0; i < times; i++) nums = blink(nums);
return nums.length;
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:croyym7fbzpi7af4ej2nlv7a/bafkreib3z6squyjmzmifvvanegcrjo6qhk6cjjkconeti76in5m5lxxzey)
![export function solve(input: string) {
const map = input.split("\n").map((line) => line.split(""));
const start: [number, number][] = [];
for (let x = 0; x < map.length; x++) {
for (let y = 0; y < map[x].length; y++) {
if (map[x][y] === "0") start.push([x, y]);
}
}
return start.reduce((acc, cur) => {
const peaks = new Set<string>();
find(...cur);
return acc + peaks.size;
function find(x: number, y: number) {
const cur = +map[x][y];
if (cur === 9) peaks.add(`${x},${y}`);
if (+map[x + 1]?.[y] === cur + 1) find(x + 1, y);
if (+map[x - 1]?.[y] === cur + 1) find(x - 1, y);
if (+map[x]?.[y + 1] === cur + 1) find(x, y + 1);
if (+map[x]?.[y - 1] === cur + 1) find(x, y - 1);
}
}, 0);
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:croyym7fbzpi7af4ej2nlv7a/bafkreieasqf7eie64i2z56vxz6qy4eoe5gtji7w5ladl56qfbtivymqpq4)
![export function solve(input: string) {
type Block = { id: number; len: number };
function expand(input: string) {
let n = 0;
return input.split("").reduce((acc, cur, i) => {
return [...acc, { id: i % 2 !== 0 ? -1 : n++, len: +cur }];
}, [] as Block[]);
}
function checkSum(blocks: Block[]) {
let sum = 0, pos = 0;
for (let i = 0, j = blocks.length - 1; i <= j;) {
if (blocks[i].id !== -1) { // is current block not empty
sum += pos++ * +blocks[i].id;
blocks[i].len--;
} else {
while (blocks[j].id === -1) j--; // skip empty
while (blocks[j].len && blocks[i].len) { // "moving"
sum += pos++ * +blocks[j].id;
blocks[j].len--;
blocks[i].len--;
}
}
if (blocks[i].len === 0) i++;
if (blocks[j].len === 0) j--;
}
return sum;
}
return checkSum(expand(input));
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:croyym7fbzpi7af4ej2nlv7a/bafkreiabuxbql5klxtw2o3yunj5p5nbtbr6tvbl54om5pple7ffv3sqveq)
![import { combinations } from "jsr:@elf/combinatorics@^1.0.14/Combinations";
export function solve(input: string) {
type Point = [number, number];
const map = new Map<string, Point[]>();
const lines = input.split("\n");
for (let x = 0; x < lines.length; x++) {
for (let y = 0; y < lines[x].length; y++) {
const c = lines[x][y];
if (c === ".") continue;
map.set(c, [...(map.get(c) ?? []), [x, y]]);
}
}
const inMap = ([x, y]: Point) =>
x >= 0 && x < lines.length && y >= 0 && y < lines[0].length;
function calcAntinode([ax, ay]: Point, [bx, by]: Point) {
return ([
[bx * 2 - ax, by * 2 - ay],
[ax * 2 - bx, ay * 2 - by],
] as Point[]).filter((n) => inMap(n));
}
const antinodes = new Set<string>();
for (const [, v] of map) {
for (const [a, b] of combinations(v, 2)) {
calcAntinode(a, b).forEach((n) => antinodes.add(`${n}`));
}
}
return antinodes.size;
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:croyym7fbzpi7af4ej2nlv7a/bafkreigcktjioh25uvm46jm5tgiporyu4r5ngumjn3enybrnj6kmejvo5q)
![export function solve(input: string) {
const formulas = input.split("\n").map((line) => {
const r = /(\d+):((?: \d+)+)/g.exec(line);
return [+r![1], [
...r![2].split(" ").filter(Boolean).map(Number),
]] as [number, number[]];
});
function check(result: number, nums: number[]): boolean {
if (nums.length < 2) return result === nums[0];
const mul = nums[0] * nums[1];
const add = nums[0] + nums[1];
return (mul <= result && check(result, [mul, ...nums.slice(2)])) ||
(add <= result && check(result, [add, ...nums.slice(2)]));
}
return formulas.reduce(
(acc, cur) => check(...cur) ? acc + cur[0] : acc,
0,
);
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:croyym7fbzpi7af4ej2nlv7a/bafkreie6ra6n55y66g5fchfvnj4jtjbb5ynklpbcqh3paer36mn57xqzaa)
![export function solve(input: string) {
const map = input.split("\n").map((s) => s.trim());
const directions = [[-1, 0], [0, 1], [1, 0], [0, -1]] as const;
const visited = Array.from(
{ length: map.length },
() => Array.from({ length: map[0].length }, () => false),
);
let direction = 0;
let x = map.findIndex((line) => line.includes("^"));
let y = map[x].indexOf("^");
function nextPosition(x: number, y: number, direction: number) {
const [dx, dy] = directions[direction];
if (map[x + dx]?.[y + dy] === "#") {
return nextPosition(x, y, (direction + 1) % directions.length);
}
return [x + dx, y + dy, direction];
}
while (x >= 0 && y >= 0 && x < map.length && y < map[0].length) {
visited[x][y] = true;
[x, y, direction] = nextPosition(x, y, direction);
}
return visited.flat().filter(Boolean).length;
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:croyym7fbzpi7af4ej2nlv7a/bafkreiabqcmenkc2l42m2ikngnjdky2w34v2edc3y2zycfoamj63brw6iq)
![export function solve(input: string) {
const [inputRules, inputPages] = input.split("\n\n").map((s) => s.trim());
const graph = new Map<number, number[]>();
inputRules.split("\n").map((s) => s.trim()).forEach(
(cur) => {
const [before, after] = cur.split("|");
if (!graph.get(+before)) graph.set(+before, []);
graph.get(+before)!.push(+after);
},
);
function check(arr: number[]) {
for (let i = 1; i < arr.length; i++) {
if (!graph.get(arr[i - 1])?.includes(arr[i])) return false;
}
return true;
}
return inputPages.split("\n").map((s) => s.trim()).reduce((acc, cur) => {
const arr = cur.split(",").map((s) => +s.trim());
if (check(arr)) return acc + arr[arr.length >> 1];
return acc;
}, 0);
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:croyym7fbzpi7af4ej2nlv7a/bafkreidmtbukxg2m44k6ihw5rebj2vicjchmo7tpey6iogelw6p22uhyae)
![solve((input) => {
const xPos: [number, number][] = [];
const arr: string[] = [];
input
.split("\n")
.map((l) => l.trim())
.forEach((line, idx) => {
arr.push(line);
xPos.push(
...[...line.matchAll(/X/g)].map(
(item) => [idx, item.index] as [number, number],
),
);
});
const target = "XMAS";
const directions: [number, number][] = [
[0, 1],
[0, -1],
[1, 0],
[-1, 0],
[1, 1],
[-1, -1],
[1, -1],
[-1, 1],
];
return xPos.reduce((acc, [x, y]) => {
for (const [dx, dy] of directions) {
if (
Array.from({ length: target.length }).every(
(_, i) => arr[x + dx * i]?.[y + dy * i] === target[i],
)
) acc++;
}
return acc;
}, 0);
});](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:croyym7fbzpi7af4ej2nlv7a/bafkreid6ddfu3v4mxlnraw2ks2sxhypqt6jopih6hdsxhxmaks3ppbqs4e)
![solve((input) => {
return input
.split("\n")
.map((l) => l.trim())
.reduce((acc, line) => {
const r = line.matchAll(/mul\((\d+),(\d+)\)/g);
acc += r.reduce(
(acc, matchResult) => acc + +matchResult[1] * +matchResult[2],
0
);
return acc;
}, 0);
});](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:croyym7fbzpi7af4ej2nlv7a/bafkreih3jlqo2jqgmlu2akuge4me4zvm4qxwnbexgi6mwh4qhkjqxdqhj4)
![solve((input) => {
function check(nums: number[]) {
const increment = nums[1] > nums[0];
for (let i = 1; i < nums.length; i++) {
if (Math.abs(nums[i - 1] - nums[i]) > 3) return false;
if (increment && nums[i - 1] >= nums[i]) return false;
if (!increment && nums[i - 1] <= nums[i]) return false;
}
return true;
}
return input
.split("\n")
.map((l) => l.trim())
.reduce((acc, line) => {
const nums = line.split(" ").map((n) => +n);
return check(nums) ? acc + 1 : acc;
}, 0);
});](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:croyym7fbzpi7af4ej2nlv7a/bafkreibcbpuicnu7zjfqb2ixexxob43orpqs5lghejwckkeoyn5as4i7gi)
![solve((input) => {
const [left, right] = input.split("\n").reduce(
(acc, line) => {
const r = /(\d+)\s+(\d+)/g.exec(line)!;
acc[0].push(+r[1]);
acc[1].push(+r[2]);
return acc;
},
[[], []] as [number[], number[]],
);
left.sort((a, b) => b - a);
right.sort((a, b) => b - a);
let sum = 0;
while (left.length) {
sum += Math.abs(left.pop()! - right.pop()!);
}
return sum;
});](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:croyym7fbzpi7af4ej2nlv7a/bafkreidql3k5zuolez3ihrtjlgtyumz7dzun3zojdhfy5ver55jphrhade)
Student | Fullstack Developer | INFP