AoC Day 8 Solution

"""
Written by nmgetahun
Github username: nmgetahun
Email: [email protected]

Advent of Code Day 8 Challenge:
https://adventofcode.com/2022/day/8
"""
# ------------------------------------------------------------------------------
# Part 1
def find_visible():
    visible_master = set()
    row_len = len(forest[0])
    for i, row in enumerate(forest):
        col = [line[i] for line in forest]
        visible_trees_horizontal = [((i, 0), row[0])]
        visible_trees_vertical = [((0, i), col[0])]

        # Traverse row left to right
        for k, tree in enumerate(row):
            if tree > visible_trees_horizontal[-1][1]:
                visible_trees_horizontal.append(((i, k), tree))

        # Traverse row right to left
        visible_trees_horizontal.append(((i, row_len - 1), row[-1]))
        for k, tree in enumerate(row[::-1]):
            if tree > visible_trees_horizontal[-1][1]:
                visible_trees_horizontal.append(((i, row_len - k - 1), tree))

        # Traverse col top to btm
        for k, tree in enumerate(col):
            if tree > visible_trees_vertical[-1][1]:
                visible_trees_vertical.append(((k, i), tree))

        # Traverse col btm to top
        visible_trees_vertical.append(((row_len - 1, i), col[-1]))
        for k, tree in enumerate(col[::-1]):
            if tree > visible_trees_vertical[-1][1]:
                visible_trees_vertical.append(((row_len - k - 1, i), tree))

        visible_master = visible_master | set(visible_trees_horizontal) | set(visible_trees_vertical)

    return len(visible_master)


# Part 2
def calculate_scenic_scores():
    max_scenic_score = -1
    best_tree = None
    for i in range(1, len(forest) - 1):
        for k in range(1, len(forest[0]) - 1):
            tree = forest[i][k]
            scenic_score = [0, 0, 0, 0]

            # Look left
            for n in range(1, i + 1):
                scenic_score[0] += 1
                if tree <= forest[i - n][k]: break

            # Look right
            for n in range(i + 1, len(forest)):
                scenic_score[1] += 1
                if tree <= forest[n][k]: break

            # Look up
            for n in range(1, k + 1):
                scenic_score[2] += 1
                if tree <= forest[i][k - n]: break

            # Look down
            for n in range(k + 1, len(forest[0])):
                scenic_score[3] += 1
                if tree <= forest[i][n]: break

            score = scenic_score[0] * scenic_score[1] * scenic_score[2] * scenic_score[3]
            if score > max_scenic_score:
                max_scenic_score = score
                best_tree = ((i, k), tree)

    print("Best Tree: ", best_tree)
    return max_scenic_score


# Main
if __name__ == "__main__":
    # Get data from today's AoC input file
    with open("aoc8input.txt") as file:
        forest = [[n for n in line.strip()] for line in file]

    # Part 1
    num_visible_trees = find_visible()

    # Part 2
    highest_scenic_score = calculate_scenic_scores()

    # Display
    print("Part 1: ", num_visible_trees, "\nPart 2: ", highest_scenic_score)