{ "_": [], "day": "08.1", "model": "gpt-4", "solve-prompt": "solve/noTemplate/2", "solvePrompt": "solve/noTemplate/2", "preSolvePrompts": [], "pre-solve-prompts": [], "solveFailedAttempts": 0, "solve-failed-attempts": 0, "$0": "src/solve.ts" }
Here is a coding problem I am trying to solve:
The expedition comes across a peculiar patch of tall trees all planted carefully in a grid. The Elves explain that a previous expedition planted these trees as a reforestation effort. Now, they're curious if this would be a good location for a tree house.
First, determine whether there is enough tree cover here to keep a tree house hidden. To do this, you need to count the number of trees that are visible from outside the grid when looking directly along a row or column.
The Elves have already launched a quadcopter to generate a map with the height of each tree (your puzzle input). For example:
30373 25512 65332 33549 35390
Each tree is represented as a single digit whose value is its height, where 0 is the shortest and 9 is the tallest.
A tree is visible if all of the other trees between it and an edge of the grid are shorter than it. Only consider trees in the same row or column; that is, only look up, down, left, or right from any given tree.
All of the trees around the edge of the grid are visible - since they are already on the edge, there are no trees to block the view. In this example, that only leaves the interior nine trees to consider:
The top-left 5 is visible from the left and top. (It isn't visible from the right or bottom since other trees of height 5 are in the way.)
The top-middle 5 is visible from the top and right.
The top-right 1 is not visible from any direction; for it to be visible, there would need to only be trees of height 0 between it and an edge.
The left-middle 5 is visible, but only from the right.
The center 3 is not visible from any direction; for it to be visible, there would need to be only trees of at most height 2 between it and an edge.
The right-middle 3 is visible from the right.
In the bottom row, the middle 5 is visible, but the 3 and 4 are not.
With 16 trees visible on the edge and another 5 visible in the interior, a total of 21 trees are visible in this arrangement.
Consider your map; how many trees are visible from outside the grid?
You must solve the problem using Deno and Typescript.
You can read files in Deno like this:
import * as path from 'https://deno.land/std@0.101.0/path/mod.ts'
const readRelativeInput = (importUrl, inputFile) => {
const dirname = path.dirname(path.fromFileUrl(importUrl))
const filePath = path.join(dirname, 'data', inputFile)
return Deno.readTextFileSync(filePath)
}The puzzle input is stored at ./data/puzzleInput.txt
The last thing your solution should do is print the answer to the puzzle on a new line like this: console.log('\n', answer)
Here's a solution using Deno and TypeScript:
import * as path from 'https://deno.land/std@0.101.0/path/mod.ts';
const readRelativeInput = (importUrl: string, inputFile: string) => {
const dirname = path.dirname(path.fromFileUrl(importUrl));
const filePath = path.join(dirname, 'data', inputFile);
return Deno.readTextFileSync(filePath);
};
const countVisibleTrees = (grid: string[][]) => {
let visibleTrees = 0;
for (let i = 0; i < grid.length; i++) {
for (let j = 0; j < grid[i].length; j++) {
const currentTree = parseInt(grid[i][j]);
const left = grid[i].slice(0, j).every(tree => parseInt(tree) < currentTree);
const right = grid[i].slice(j + 1).every(tree => parseInt(tree) < currentTree);
const up = grid.slice(0, i).every(row => parseInt(row[j]) < currentTree);
const down = grid.slice(i + 1).every(row => parseInt(row[j]) < currentTree);
if (left || right || up || down) {
visibleTrees++;
}
}
}
return visibleTrees;
};
const main = () => {
const input = readRelativeInput(import.meta.url, 'puzzleInput.txt');
const grid = input.trim().split('\n').map(line => line.split(''));
const answer = countVisibleTrees(grid);
console.log('\n', answer);
};
main();This solution defines a countVisibleTrees function that takes a 2D array of strings representing the grid of trees. It iterates through each tree in the grid and checks if it's visible from any direction (left, right, up, or down). If a tree is visible from any direction, it increments the visibleTrees counter. Finally, it returns the total number of visible trees.
The main function reads the puzzle input, converts it into a 2D array, and calls countVisibleTrees with the grid. It then prints the answer on a new line.
formatting
import * as path from "https://deno.land/std@0.101.0/path/mod.ts";
const readRelativeInput = (importUrl: string, inputFile: string) => {
const dirname = path.dirname(path.fromFileUrl(importUrl));
const filePath = path.join(dirname, "data", inputFile);
return Deno.readTextFileSync(filePath);
};
const countVisibleTrees = (grid: string[][]) => {
let visibleTrees = 0;
for (let i = 0; i < grid.length; i++) {
for (let j = 0; j < grid[i].length; j++) {
const currentTree = parseInt(grid[i][j]);
const left = grid[i].slice(0, j).every((tree) =>
parseInt(tree) < currentTree
);
const right = grid[i].slice(j + 1).every((tree) =>
parseInt(tree) < currentTree
);
const up = grid.slice(0, i).every((row) =>
parseInt(row[j]) < currentTree
);
const down = grid.slice(i + 1).every((row) =>
parseInt(row[j]) < currentTree
);
if (left || right || up || down) {
visibleTrees++;
}
}
}
return visibleTrees;
};
const main = () => {
const input = readRelativeInput(import.meta.url, "puzzleInput.txt");
const grid = input.trim().split("\n").map((line) => line.split(""));
const answer = countVisibleTrees(grid);
console.log("\n", answer);
};
main();solution: 1719, actual solution: 1719 Solved! Day 08.1 result: ✅ Attempts: 1 Time Taken (secs): 36 GPT Requests: 1 Cost: $0.04665