예제 #1
0
파일: day_14.py 프로젝트: jdpatt/AoC
def main():
    """Main Puzzle Entry."""
    recipes = int(get_puzzle_input("input/input14.txt")[0])
    scoreboard = [3, 7]
    elf1 = 0  # The first elf picks the score at index 0
    elf2 = 1  # The second elf gets the next one
    print(
        "Part 1:  Return 10 Recipes after number of iterations from puzzle input."
    )
    while len(scoreboard) < recipes + 10:
        scoreboard, elf1, elf2 = create_new_recipe(scoreboard, elf1, elf2)
    print("".join([str(x) for x in scoreboard[-10:]]))

    print("Part 2:  Return index of pattern match from puzzle input.")
    scoreboard = [3, 7]
    elf1 = 0  # The first elf picks the score at index 0
    elf2 = 1  # The second elf gets the next one
    pattern = [int(letter) for letter in str(recipes)]
    while True:
        scoreboard, elf1, elf2 = create_new_recipe(scoreboard, elf1, elf2)
        try:
            index = find_sub_list(scoreboard[-20:], pattern)
            if index:
                length = len(scoreboard) - (20 - index)
                print(f"Pattern Appears at {length}")
                print(scoreboard[-20:])
                break
        except ValueError:
            pass
예제 #2
0
파일: day_16.py 프로젝트: jdpatt/AoC
def main():
    """Main Puzzle Entry."""
    puzzle = get_puzzle_input("input/input16.txt")
    samples = get_sample_operations("input/input16.txt")
    print("Part 1: How many samples behave like 3 or more opcodes?")
    print(len(find_ops_that_match_xplus(samples, 3)))

    print("Part 2: Find the opcode numbers, run the program and return register 0.")
    dev = solve_opcodes(samples)
    dev.run_program(transform_program(puzzle[3005:]))
    print(dev)
예제 #3
0
파일: day_19.py 프로젝트: jdpatt/AoC
def main():
    """Main Puzzle Entry."""
    puzzle = get_puzzle_input("input/input19.txt")
    program = transform_program(puzzle[1:])
    print("Part 1: What is left in register 0 after the program ends.")
    dev = Device(instruction_register=int(puzzle[0][3:]))
    dev.run_program_with_flow_control(program)
    print(dev)
    print(
        "Part 2: Register 0 started with the value 1. What is left after the program?"
    )
    dev2 = Device(registers=[1, 0, 0, 0, 0, 0], instruction_register=int(puzzle[0][3:]))
    dev2.run_program_with_flow_control(program)
    print(dev2)
예제 #4
0
def print_grid(points):
    """Print the grid of points using the smallest and largest points as the bounding box."""
    x_bound = get_x_boundary(points)
    y_bound = get_y_boundary(points)
    for row in range(y_bound[0], y_bound[1] + 1):
        for column in range(x_bound[0], x_bound[1] + 1):
            if location_exists_at_points(points, column, row):
                print("#", end="")
            else:
                print(".", end="")
        print()


if __name__ == "__main__":
    PUZZLE = get_puzzle_input("input/input10.txt")
    POINTS = get_points_from_input(PUZZLE)
    for point in POINTS:
        point.advance(10086)
    print_grid(POINTS)


def test_location():
    """Verify that we can advance n steps correctly."""
    location = Location(Point(0, 0), Velocity(1, -1))
    location.advance(1)
    assert location.point == {"x": 1, "y": -1}
    location.advance(2)
    assert location.point == {"x": 3, "y": -3}

예제 #5
0
파일: day_1.py 프로젝트: jdpatt/AoC
"""Advent of Code 2018 Day 1"""
from shared.common import get_puzzle_input


def device_calibration(frequencies):
    """Calculate the final frequency drift after falling in time."""
    return sum(frequency for frequency in frequencies)


def find_repeating_frequency(frequencies):
    """Find the first frequency that repeats."""
    seen_frequencies = set()
    current_freq = 0
    while True:
        for frequency in frequencies:
            current_freq += frequency
            if current_freq not in seen_frequencies:
                seen_frequencies.add(current_freq)
            else:
                return current_freq


if __name__ == "__main__":
    frequencies = [int(x) for x in get_puzzle_input("input/input1.txt")]
    print(f"Final Frequency: {device_calibration(frequencies)}")
    print(f"First Repeated: {find_repeating_frequency(frequencies)}")
예제 #6
0
파일: day_8.py 프로젝트: jdpatt/AoC
        self.value = 0


def generate_nodes(tree, data, parent):
    """Walk through the tree, recursively generating nodes"""
    node = Node(parent)
    num_of_children = next(data)
    num_of_metadata = next(data)
    for _ in range(num_of_children):
        tree, data, val = generate_nodes(tree, data, node)
        node.child_values.append(val)
    for _ in range(num_of_metadata):
        node.meta.append(next(data))
    if num_of_children == 0:
        node.value = sum(node.meta)
    else:
        for val in node.meta:
            try:
                node.value += node.child_values[val - 1]
            except IndexError:
                pass
    tree.append(node)
    return tree, data, node.value


if __name__ == "__main__":
    PUZZLE = [int(x) for x in get_puzzle_input("input/input8.txt")[0].split(" ")]
    TREE, _, ROOT_VALUE = generate_nodes([], iter(PUZZLE), "Root")
    print(f"Metadata sum: {sum([sum(node.meta) for node in TREE])}")
    print(f"Root Value: {ROOT_VALUE}")
예제 #7
0
파일: day_9.py 프로젝트: jdpatt/AoC
def play_marbles(num_of_players, num_of_marbles):
    """Play a game of marbles with the elves."""
    player = cycle([x for x in range(num_of_players)])
    score = {key: 0 for key in range(num_of_players)}
    current_marble = Marble(0)
    current_marble.next = current_marble
    current_marble.previous = current_marble
    for marble, current_player in zip(range(1, num_of_marbles + 1), player):
        if marble % 23 == 0:
            score[current_player] += marble
            for _ in range(7):
                current_marble = current_marble.previous
            score[current_player] += current_marble.number
            current_marble = current_marble.remove()
        else:
            current_marble = current_marble.next.append(marble)
    return max(value for _, value in score.items())


if __name__ == "__main__":
    PUZZLE = get_puzzle_input("input/input9.txt")[0].split(" ")
    PLAYERS = int(PUZZLE[0])
    LAST_MARBLE = int(PUZZLE[6])
    FINAL_SCORE = play_marbles(PLAYERS, LAST_MARBLE)
    # print(f"32: {play_marbles(9, 25)}")
    # print(f"8317: {play_marbles(10, 1618)}")
    # print(f"146373: {play_marbles(13, 7999)}")
    # print(f"2764: {play_marbles(17, 1104)}")
    print(f"Final Score is {FINAL_SCORE}")
    print(f"Jackpot is {play_marbles(PLAYERS, LAST_MARBLE * 100)}")
예제 #8
0
파일: day_6.py 프로젝트: jdpatt/AoC
            count += 1
            closest_point, total_distance = get_nearest_point((x, y), points)
            if y == 0 or y == (upper["y"] - 1) or x == 0 or x == (upper["x"] -
                                                                  1):
                infinite_points.add(closest_point)
            if total_distance < 10000:
                safe_regions.append((x, y))
            grid[x][y] = closest_point
    print(f"Safe Region Size: {len(safe_regions)}")
    return grid, {p: v for p, v in points.items() if p not in infinite_points}


if __name__ == "__main__":
    COORDINATES = [(int(x[0]), int(x[1]))
                   for x in (x.split(",")
                             for x in get_puzzle_input("input/input6.txt"))]
    UPPER = get_upper_boundary(COORDINATES)
    NEW_COORDINATES = {key: value for key, value in enumerate(COORDINATES)}
    GRID, VALID_POINTS = generate_and_fill_grid(UPPER, NEW_COORDINATES)
    AREAS = get_largest(GRID, VALID_POINTS)
    LARGEST = AREAS.most_common(1)[0]
    print(f"Largest Area: {VALID_POINTS[LARGEST[0]]} Size: {LARGEST[1]}")


def test_manhattan_distance():
    """Make sure that the rise/run is being calculated correctly."""
    assert manhattan_distance((1, 1), (2, 2)) == 2
    assert manhattan_distance((1, 2), (2, 2)) == 1
    assert manhattan_distance((1, 3), (2, 2)) == 2