Advent of Code 2022 Day 8, Part 1. My answer is not matching the answer expected, but I am getting t-CodePudding

Here is the problem for advent of code 2022, Day 8.

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?

And here is my code solving that:

with open('day8.in') as file:
    forest = file.read().strip()

trees = [list(x) for x in forest.split('\n')]

visible = (len(trees) - 1) * 4

for i in range(1, len(trees) - 1):
    for j in range(1, len(trees[i]) - 1):

        if trees[i][j] > trees[i][j - 1]:
            for k in range(j - 1, -1, -1):
                if trees[i][k] > trees[i][j]:
                    break
                if k == 0 and trees[i][k] < trees[i][j]:
                    visible  = 1

        elif trees[i][j] > trees[i][j   1]:
            for k in range(j   1, len(trees[i])):
                if trees[i][k] > trees[i][j]:
                    break
                if k == len(trees[i]) - 1 and trees[i][k] < trees[i][j]:
                    visible  = 1

        elif trees[i][j] > trees[i - 1][j]:
            for k in range(i - 1, -1, -1):
                if trees[k][j] > trees[i][j]:
                    break
                if k == 0 and trees[k][j] < trees[i][j]:
                    visible  = 1

        elif trees[i][j] > trees[i   1][j]:
            for k in range(i   1, len(trees)):
                if trees[k][j] > trees[i][j]:
                    break
                if k == len(trees) - 1 and trees[k][j] < trees[i][j]:
                    visible  = 1

print(visible)

I am getting 21 for the example which I should be getting, but with the actual input, it's saying my answer is not correct and I can't find out!

I tried printing throughout my code and from the example, it seems as if I was doing exactly what I wanted to do.

I checked for the actual input and I believe it was a 99x99 grid, so I believe my initial visible variable is correct too.

The actual input is too large for me to manually go through and figure out where I am going wrong.

CodePudding user response：

There are two main issues.

Firstly, for each loop, you're checking this:

if trees[i][k] > trees[i][j]:
    break

This is wrong, because the tree will ideally not be visible even if a tree of the same height is in the way. You should check for equality as well (if trees[i][k] >= trees[i][j])

Secondly, your "if-elif" logic is wrong. Let's say a tree is greater in height than all 4 neighboring trees. You will only enter the first if block. However, if the tree isn't visible along that path, you won't check the other paths (that is, the other elif blocks). This would be an easy fix, so I'll leave it for the you to implement.