def solve():
"""Advent Of Code 2017 - Day 02 Solution.
:return: tuple(part_a_result[int], part_b_result[int])
"""
part_a_result = 0
part_b_result = 0
INPUT_DELIMITER = " "
for puzzle_input in read_puzzle_input(
os.path.dirname(os.path.abspath(__file__)), "day_02_input.txt"):
numbers_on_line = [
int(number)
for number in puzzle_input.rstrip().split(INPUT_DELIMITER)
]
# Part-A
part_a_result += max(numbers_on_line) - min(numbers_on_line)
# Part-B
part_b_result += sum(
div_wo_rem[0] // div_wo_rem[1]
for div_wo_rem in itertools.permutations(numbers_on_line, 2)
if div_wo_rem[0] % div_wo_rem[1] == 0)
return part_a_result, part_b_result
def solve():
"""Advent Of Code 2017 - Day 01 Solution.
:return: tuple(part_a_result[int], part_b_result[int])
"""
def circular_buffer_position(length, offset, order):
return (offset + order) % length
# Read first line from the input file
try:
puzzle_input = read_puzzle_input(
os.path.dirname(os.path.abspath(__file__)), "day_01_input.txt")[0]
except IndexError:
return -1, -1
# Part-A
part_a_result = sum(
int(puzzle_input[i]) for i in range(len(puzzle_input))
if puzzle_input[i] == puzzle_input[circular_buffer_position(
len(puzzle_input), i, 1)])
# Part-B
part_b_result = sum(
int(puzzle_input[i]) for i in range(len(puzzle_input))
if puzzle_input[i] == puzzle_input[circular_buffer_position(
len(puzzle_input), i,
len(puzzle_input) // 2)])
return part_a_result, part_b_result
def solvePuzzle(carriers, visited_places):
from puzzle_commons.puzzle_commons import read_puzzle_input
import os
for carrier in carriers:
visitPoint(visited_places, carrier.current_position)
for puzzle_input in read_puzzle_input(os.path.dirname(os.path.abspath(__file__)),"puzzle_03_input.txt"):
i = 0
for direction in puzzle_input:
current_carrier = carriers[i%len(carriers)]
i += 1
if direction == "<":
current_carrier.moveW()
elif direction == ">":
current_carrier.moveE()
elif direction == "^":
current_carrier.moveN()
else:
current_carrier.moveS()
visitPoint(visited_places, current_carrier.current_position)
def solve():
"""Advent Of Code 2017 - Day 09 Solution.
:return: tuple(part_a_result[int], part_b_result[int])
"""
puzzle_input = read_puzzle_input(
os.path.dirname(os.path.abspath(__file__)), "day_09_input.txt")[0]
def solve_a():
"""Advent Of Code 2017 - Day 09 - Part A Solution.
"""
total_score = 0
score_multipler = 0
inside_junk = False
i = 0
while i < len(puzzle_input):
if not inside_junk:
if puzzle_input[i] == "{":
score_multipler += 1
elif puzzle_input[i] == "}":
total_score += score_multipler
score_multipler -= 1
elif puzzle_input[i] == "<":
inside_junk = True
elif inside_junk:
if puzzle_input[i] == ">":
inside_junk = False
elif puzzle_input[i] == "!":
i += 1
i += 1
return total_score
def solve_b():
"""Advent Of Code 2017 - Day 10 - Part B Solution.
"""
garbage_count = 0
inside_junk = False
i = 0
while i < len(puzzle_input):
if not inside_junk and puzzle_input[i] == "<":
inside_junk = True
elif inside_junk:
if puzzle_input[i] == ">":
inside_junk = False
elif puzzle_input[i] == "!":
i += 1
else:
garbage_count += 1
i += 1
return garbage_count
return solve_a(), solve_b()
def solve():
target_aunt_properties = """children: 3,
cats: 7,
samoyeds: 2,
pomeranians: 3,
akitas: 0,
vizslas: 0,
goldfish: 5,
trees: 3,
cars: 2,
perfumes: 1"""
target_aunt_properties = unpack_properties(target_aunt_properties)
puzzle_a_solution = None
puzzle_b_solution = None
for puzzle_input in read_puzzle_input(
os.path.dirname(os.path.abspath(__file__)), "puzzle_16_input.txt"):
incorrect_aunt = False
aunt_name, properties = puzzle_input.split(":", maxsplit=1)
properties = unpack_properties(properties)
# Check if solution for Puzzle_A, if it has not been found already
if puzzle_a_solution is None:
if compare_aunts_puzzle_a(properties, target_aunt_properties):
puzzle_a_solution = aunt_name
# Check if solution for Puzzle_B, if it has not been found already
if puzzle_b_solution is None:
if compare_aunts_puzzle_b(properties, target_aunt_properties):
puzzle_b_solution = aunt_name
print("Puzzle16, part A:{}".format(puzzle_a_solution))
print("Puzzle16, part B:{}".format(puzzle_b_solution))
def solve():
from puzzle_commons.puzzle_commons import read_puzzle_input
import os
import re
puzzle_part_A = LightGrid(999,999)
puzzle_part_B = DimmableLightGrid(999,999)
grids_to_operate = (puzzle_part_A, puzzle_part_B)
for puzzle_input in read_puzzle_input(os.path.dirname(os.path.abspath(__file__)), "puzzle_06_input.txt"):
lightInstructionMatcher = re.search(r"(toggle|(?<=turn.)on|off)\D+(\d+,\d+)\D+(\d+,\d+)", puzzle_input)
if lightInstructionMatcher is not None:
instruction = lightInstructionMatcher.group(1)
(startX, startY) = [int(s) for s in lightInstructionMatcher.group(2).split(",")]
(endX, endY) = [int(s) for s in lightInstructionMatcher.group(3).split(",")]
for grid_to_operate in grids_to_operate:
if instruction == "on":
grid_to_operate.turnRangeOn(startX, startY, endX, endY)
elif instruction == "off":
grid_to_operate.turnRangeOff(startX, startY, endX, endY)
elif instruction == "toggle":
grid_to_operate.toggleRange(startX, startY, endX, endY)
print("Puzzle06, part A:{}".format(puzzle_part_A.getTotalBrightness()))
print("Puzzle06, part B:{}".format(puzzle_part_B.getTotalBrightness()))
def solve():
from puzzle_commons.puzzle_commons import read_puzzle_input
import os
for puzzle_input in read_puzzle_input(
os.path.dirname(os.path.abspath(__file__)), "puzzle_01_input.txt"):
print("Puzzle01, part A:", count_floors(puzzle_input))
print("Puzzle01, part B:", find_first_underground(puzzle_input) + 1)
def solve():
from puzzle_commons.puzzle_commons import read_puzzle_input
import os
for puzzle_input in read_puzzle_input(os.path.dirname(os.path.abspath(__file__)), "puzzle_04_input.txt"):
print("Puzzle04, part A:{}".format(getAdventCoin(puzzle_input, 5)))
print("Puzzle04, part B:{}".format(getAdventCoin(puzzle_input, 6)))
def solve_part(is_better):
"""Solves puzzle_09, based on given evaluation function.
Returns best path according to evaluation function."""
puzzle_map = distancesMap() # Distances between cities
node_queue = [] # Queue of solutions to be processed
best_known_solution = None # Best known solution
# Load instructions
for puzzle_input in read_puzzle_input(os.path.dirname(os.path.abspath(__file__)), "puzzle_09_input.txt"):
"""Find instructions in format: (START_CITY) to (END_CITY) -> (DISTANCE)"""
map_instruction = re.search(r"(\w+)\sto\s(\w+)\s=\s(\d+)", puzzle_input)
if map_instruction is not None:
puzzle_map.addDistance(map_instruction.group(1), map_instruction.group(2), map_instruction.group(3))
"""
Add initial Path to get processed.
At this stage, no city has been visited.
"""
node_queue.append(Path())
# Repeat, until there are no possible solutions to explored
while len(node_queue) > 0:
# Pick the first in queue
current_path = node_queue.pop(0)
"""
Check, whether explored path can be better (shorter/longer, depending on part A/B).
If it's already worse then best known solution, it's not worth checking or exploring further.
Example: If searching for shortest path, it's not worth visiting next place, if currently walked distance is already
better then any existing solution.
"""
# if best_known_solution is None or puzzle_map.getTotalDistance(
# current_path.getVisitedPlaces()) > puzzle_map.getTotalDistance(
# best_known_solution.getVisitedPlaces()):
if best_known_solution is None or is_better(puzzle_map.getTotalDistance(current_path.getVisitedPlaces()),
puzzle_map.getTotalDistance(
best_known_solution.getVisitedPlaces())):
# Check whether it's solution => all places have been visited
if set(current_path.getVisitedPlaces()) == puzzle_map.getAllPoints():
# Store as new best solution
best_known_solution = current_path
else:
# Find which places need to be visited by substracting already visited from all places
places_left_to_visit = (point for point in puzzle_map.getAllPoints() if
point not in current_path.getVisitedPlaces())
# Generate new possible solutions
for place_to_visit in places_left_to_visit:
node_queue.append(Path(current_path.getVisitedPlaces(), place_to_visit))
return best_known_solution, puzzle_map.getTotalDistance(best_known_solution.getVisitedPlaces())
def solve():
# Load instructions
for puzzle_input in read_puzzle_input(
os.path.dirname(os.path.abspath(__file__)), "puzzle_12_input.txt"):
# Decode puzzle input into string
decoded_json = json.loads(puzzle_input)
# Get value, counting also "red" objects
print("Puzzle12, part A:{}".format(solve_puzzle12(decoded_json,
False)))
# Get value ignoring "red" objects
print("Puzzle12, part B:{}".format(solve_puzzle12(decoded_json, True)))
def solve_a():
numbers = []
# TEST INPUT
# for puzzle_row in read_puzzle_input(os.path.dirname(os.path.abspath(__file__)), "puzzle_24_test_input.txt"):
# numbers.append(int(puzzle_row.strip()))
print(sum(numbers)/3)
# ACTUAL INPUT
for puzzle_row in read_puzzle_input(os.path.dirname(os.path.abspath(__file__)), "puzzle_24_input.txt"):
numbers.append(int(puzzle_row.strip()))
enquantum = None
first_length = None
# puzzle - A
for i in range(len(numbers)-2):
groups = itertools.combinations(numbers, i)
# 1st level
for group in groups:
if sum(group) == sum(numbers)/3:
if first_length is None:
first_length = len(group)
elif len(group) > first_length:
return
from operator import mul
import functools
if enquantum is None:
enquantum = functools.reduce(mul, group, 1)
print(enquantum)
elif functools.reduce(mul, group, 1) >= enquantum:
return
# print(group)
reduced_group = numbers[:]
for group_member in group:
reduced_group.remove(group_member)
#2nd level
for i in range(len(reduced_group) - 1):
groups2nd = itertools.combinations(reduced_group, i)
for group2nd in groups2nd:
if sum(group2nd) == sum(reduced_group) / 2:
# print(group)
reduced_group2nd = reduced_group[:]
for group_member2nd in group2nd:
reduced_group2nd.remove(group_member2nd)
# print("{}, {}, {}".format(group, group2nd, reduced_group2nd))
print("Equantum: {}".format(enquantum))
def solve():
"""Advent Of Code 2017 - Day 15 Solution.
:return: tuple(part_a_result[int], part_b_result[int])
"""
def generate_value_with_criteria(initial_value, factor, criteria=1):
"""Gets next value for iterator, which fits condition new_value%criteria == 0.
"""
# Repeat, until suitable value is found
while True:
initial_value = (initial_value * factor) % 2147483647
if (initial_value % criteria) == 0:
return initial_value
def solve_puzzle(generator_one, generator_two, iterations):
matches_found = 0
for i in range(iterations):
# Compare last 16 bits of each generator
if generator_one[0] & 0xFFFF == generator_two[0] & 0xFFFF:
matches_found += 1
generator_one[0] = generate_value_with_criteria(*generator_one)
generator_two[0] = generate_value_with_criteria(*generator_two)
return matches_found
# Read puzzle input
generator_initial_values = [
int(initial_value[24:]) for initial_value in read_puzzle_input(
os.path.dirname(os.path.abspath(__file__)), "day_15_input.txt")
]
generator_one = [generator_initial_values[0]] + [
16807
] # Value read from input + step size from requirements
generator_two = [generator_initial_values[1]] + [
48271
] # Value read from input + step size from requirements
def solve_a():
"""Advent Of Code 2017 - Day 15 - Part A Solution.
"""
puzzle_a_generators = (generator_one[:], generator_two[:]
) # Copy generators read from puzzle
return solve_puzzle(*puzzle_a_generators, 40000000)
def solve_b():
"""Advent Of Code 2017 - Day 15 - Part B Solution.
"""
# Copy generators read from puzzle input and add conditions given by requirements
puzzle_b_generators = (generator_one[:] + [4], generator_two[:] + [8])
return solve_puzzle(*puzzle_b_generators, 5000000)
return solve_a(), solve_b()
def solve():
"""Advent Of Code 2017 - Day 17 Solution.
:return: tuple(part_a_result[int], part_b_result[int])
"""
puzzle_input = int(
read_puzzle_input(os.path.dirname(os.path.abspath(__file__)),
"day_17_input.txt")[0])
def solve_a():
"""Advent Of Code 2017 - Day 17 - Part A Solution.
"""
buffer = [0]
current_position = 0
loop_times = 2017
part_a_result = 0
# Calculate all values in buffer
for i in range(1, loop_times + 1):
current_position = (
(current_position + puzzle_input) % len(buffer)) + 1
buffer.insert(current_position, i)
# Get value immediate following one, which has been populated last
for j in range(len(buffer)):
if buffer[j] == loop_times:
part_a_result = buffer[j + 1]
break
return part_a_result
def solve_b():
"""Advent Of Code 2017 - Day 17 - Part B Solution.
"""
current_position = 0
buffer_length = 1
loop_times = 50000000
part_b_result = 0
# Calculated values are not stored, since we are interested in one on 1st position only
for i in range(1, loop_times + 1):
current_position = (
(current_position + puzzle_input) % buffer_length) + 1
buffer_length += 1
# Remember iteration, which caused value to be written to position 1
if current_position == 1:
part_b_result = i
return part_b_result
return solve_a(), solve_b()
def solve_a():
"""Advent Of Code 2017 - Day 11 - Part A Solution.
"""
target_point = initial_point[:]
for direction in read_puzzle_input(
os.path.dirname(os.path.abspath(__file__)),
"day_11_input.txt")[0].split(","):
target_point = tuple(
a + b for a, b in zip(target_point, directions[direction]))
return hexagrid_distance(target_point, initial_point)
def solve():
"""Advent Of Code 2017 - Day 13 Solution.
:return: tuple(part_a_result[int], part_b_result[int])
"""
scanners = {}
for puzzle_input in read_puzzle_input(os.path.dirname(os.path.abspath(__file__)), "day_13_input.txt"):
# Strip whitespace, split by ": ", cast to integer
scanner_depth, scanner_range = (int(param) for param in puzzle_input.strip().split(": "))
scanners[scanner_depth] = scanner_range
# Sort scanner levels
# 1) Just in case, they came unsorted in input
# 2) Python doesn't guarantee order of keys()
scanner_levels = list(scanners.keys())
scanner_levels.sort()
def solve_a():
severity = 0
for scanner_level in scanner_levels:
# Packet is falling through 0th position. If it meets with scanner, increase severity.
if get_scanner_position(scanners[scanner_level], scanner_level) == 0:
# add up depth * range
severity += (scanner_level * scanners[scanner_level])
return severity
def solve_b():
initial_delay = 0 # Set initial delay 0
# Try passing the firewall, until the solution is found
while True:
firewall_passed = True
for scanner in scanner_levels:
# If the packet is blocked by firewall, increase initial delay and try again
if get_scanner_position(scanners[scanner], scanner + initial_delay) == 0:
initial_delay += 1
firewall_passed = False
break
# Break out of outer loop, when the firewall has been passed
if firewall_passed:
break
return initial_delay
return solve_a(), solve_b()
def solve():
"""Advent Of Code 2017 - Day 06 Solution.
:return: tuple(part_a_result[int], part_b_result[int])
"""
puzzle_input = [int(puzzle_input) for puzzle_input in
read_puzzle_input(os.path.dirname(os.path.abspath(__file__)), "day_06_input.txt")[0].split(" ")]
class MemoryBank:
def __init__(self, memory_bank_state):
self.memory_bank_state = memory_bank_state[:]
self.seen_states = []
def redistribute_fullest_block(self):
fullest_block_index = None
# Find fullest memory block
for i in range(len(self.memory_bank_state)):
if fullest_block_index is None or self.memory_bank_state[i] > self.memory_bank_state[fullest_block_index]:
fullest_block_index = i
# Clear out fullest block
amount_to_redistribute = self.memory_bank_state[fullest_block_index]
self.memory_bank_state[fullest_block_index] = 0
# Redistribute amount to other blocks
next_register_index = fullest_block_index + 1
while amount_to_redistribute > 0:
self.memory_bank_state[next_register_index%len(self.memory_bank_state)] += 1
next_register_index += 1
amount_to_redistribute -= 1
def reallocate(self):
total_steps = 0
while tuple(self.memory_bank_state) not in self.seen_states:
self.seen_states.append(tuple(self.memory_bank_state))
self.redistribute_fullest_block()
total_steps += 1
return total_steps
def distance_from_state_to_state(self):
return len(self.seen_states) - self.seen_states.index(tuple(self.memory_bank_state))
memory_bank_one = MemoryBank(puzzle_input)
return memory_bank_one.reallocate(), memory_bank_one.distance_from_state_to_state()
def solve():
puzzle_a_result = 0
puzzle_b_result = 0
# Load instructions
for puzzle_input in read_puzzle_input(
os.path.dirname(os.path.abspath(__file__)), "puzzle_08_input.txt"):
# Total length + length of original input - length of string without quotes
puzzle_a_result = puzzle_a_result + len(puzzle_input) - len(
part_a(puzzle_input))
puzzle_b_result = puzzle_b_result + len(
part_b(puzzle_input)) - len(puzzle_input) + 2
print("Puzzle08, part A:{}".format(puzzle_a_result))
print("Puzzle08, part B:{}".format(puzzle_b_result))
def solve():
from puzzle_commons.puzzle_commons import read_puzzle_input
import os
partACount = 0
partBCount = 0
for puzzle_input in read_puzzle_input(os.path.dirname(os.path.abspath(__file__)), "puzzle_05_input.txt"):
if isPartAValid(puzzle_input):
partACount += 1
if isPartBValid(puzzle_input):
partBCount += 1
print("Puzzle05, part A:{}".format(partACount))
print("Puzzle05, part B:{}".format(partBCount))
def load_puzzle_input():
global initial_molecule
for puzzle_row in read_puzzle_input(
os.path.dirname(os.path.abspath(__file__)), "puzzle_19_input.txt"):
if "=>" in puzzle_row:
replace_from, replace_to = puzzle_row.split(" => ")
replace_from.strip()
replace_to = replace_to.strip()
# print("{} to {}".format(replace_from, replace_to))
mappings = replacements.get(replace_from, [])
mappings = mappings + [replace_to]
replacements[replace_from] = mappings
else:
initial_molecule = puzzle_row
def solve():
computer_instructions = []
# TEST INPUT
# for puzzle_row in read_puzzle_input(os.path.dirname(os.path.abspath(__file__)), "puzzle_23_test_input.txt"):
# ACTUAL INPUT
for puzzle_row in read_puzzle_input(
os.path.dirname(os.path.abspath(__file__)), "puzzle_23_input.txt"):
computer_instructions.append(puzzle_row.strip())
puzzle_a = SimpleComputer(computer_instructions)
puzzle_a.process_instructions()
print("Day-23 puzzle-A solution: {}".format(puzzle_a.get_registers()["b"]))
puzzle_b = SimpleComputerPB(computer_instructions)
puzzle_b.process_instructions()
print("Day-23 puzzle-B solution: {}".format(puzzle_b.get_registers()["b"]))
def solve():
# Load instructions
for puzzle_input in read_puzzle_input(
os.path.dirname(os.path.abspath(__file__)), "puzzle_10_input.txt"):
part_a_result = puzzle_input
part_b_result = puzzle_input
# Puzzle10 - part A
for i in range(40):
part_a_result = look_and_say(part_a_result)
print("Puzzle10, part A:{}".format(len(part_a_result)))
# Puzzle10 - part B
# Note: runs very long
for i in range(50):
part_b_result = look_and_say(part_b_result)
print("Puzzle10, part B:{}".format(len(part_b_result)))
def solve():
""""Prints solution for the Puzzle02"""
from puzzle_commons.puzzle_commons import read_puzzle_input
import os
wrap_total = 0
ribbon_total = 0
for puzzle_input in read_puzzle_input(
os.path.dirname(os.path.abspath(__file__)), "puzzle_02_input.txt"):
dimensions = puzzle_input.split("x")
current_present = Present(int(dimensions[0]), int(dimensions[1]),
int(dimensions[2]))
wrap_total += current_present.get_wrap()
ribbon_total += current_present.get_ribbon()
print("Puzzle02, part A:", wrap_total)
print("Puzzle02, part B:", ribbon_total)
def solve_b():
"""Advent Of Code 2017 - Day 11 - Part B Solution.
"""
target_point = initial_point[:]
furthest_from_init = 0
for direction in read_puzzle_input(
os.path.dirname(os.path.abspath(__file__)),
"day_11_input.txt")[0].split(","):
target_point = tuple(
a + b for a, b in zip(target_point, directions[direction]))
distance_from_start = hexagrid_distance(target_point,
initial_point)
# Remember distance, if we're further from init than before
if distance_from_start > furthest_from_init:
furthest_from_init = distance_from_start
return furthest_from_init
def solve():
global gates
global gates_cache
# Load instructions
for puzzle_input in read_puzzle_input(
os.path.dirname(os.path.abspath(__file__)), "puzzle_07_input.txt"):
"""Regexp explanation:
(?:([a-z0-9]+)\s){0,1} - optional group(1) of small letters/numbers - left operand
(?:(OR|AND|LSHIFT|RSHIFT|NOT)\s){0,1}- optional operator - group(2)
([a-z0-9]+) - always present group(3) of small letters/numbers - right operand
\s->\s - assignment notation (not captured in a group)
(\w+) - group(4) - register name"""
instruction_matcher = re.search(
r"(?:([a-z0-9]+)\s){0,1}(?:(OR|AND|LSHIFT|RSHIFT|NOT)\s){0,1}([a-z0-9]+)\s->\s(\w+)",
puzzle_input)
# Check, whether line loaded from file is valid register operation
if instruction_matcher is not None:
gates[instruction_matcher.group(4)] = {
"leftOperand": instruction_matcher.group(1),
"operator": instruction_matcher.group(2),
"rightOperand": instruction_matcher.group(3)
}
# PUZZLE07 - part A
puzzle07_part_a = resolveGate("a")
print("Puzzle07, part A:{}".format(puzzle07_part_a))
# PUZZLE07 - part B
# Add new instruction - assign solution from part A to wire-B
gates["b"] = {
"leftOperand": None,
"operator": None,
"rightOperand": str(puzzle07_part_a)
}
# Flush gates cache
gates_cache = {}
puzzle07_part_b = resolveGate("a")
print("Puzzle07, part B:{}".format(puzzle07_part_b))
def solve():
numbers = []
# Load test puzzle input
for puzzle_row in read_puzzle_input(os.path.dirname(os.path.abspath(__file__)), "puzzle_24_test_input.txt"):
numbers.append(int(puzzle_row.strip()))
def split_in_equal_parts(list_of_numbers, parts):
# Find all combinations of length 1 - (list_of_numbers-parts+1)
## e.g: there are 5 numbers to split in 3 groups;
### find combinations of 'up to 3' (5-3+1) = 3
### each group must contain at least 1 number
max_comb_length = len(list_of_numbers)-parts+1
for comb_length in range(1, max_comb_length):
all_combinations = itertools.combinations(numbers, comb_length)
# Check each combination, whether it gives sum of sum(list_of_numbers/parts)
for tested_combination in all_combinations:
if sum(tested_combination) == sum(list_of_numbers)/parts:
def solve():
"""Advent Of Code 2017 - Day 05 Solution.
:return: tuple(part_a_result[int], part_b_result[int])
"""
# Read puzzle input, cast to integer and store in list
input_instructions = [
int(puzzle_input) for puzzle_input in read_puzzle_input(
os.path.dirname(os.path.abspath(__file__)), "day_05_input.txt")
]
def steps_required_to_reach_exit(jump_instructions, offset_adjustment_fn):
"""Returns number of steps required to exit from list of offset / instructions.
:param jump_instructions: list([integer]) list of instructions / offsets
:param offset_adjustment_fn: function accepting single [integer] offset, returning [integer] value to be added to index in each step
:return: [integer] number of instructions
"""
# Create copy of instructions list in order to avoid modifying input list directly
jump_instructions = jump_instructions[:]
steps_to_exit_instructions = 0
i = 0
# Loop until instruction index is inside range of instructions
while i < len(jump_instructions):
# Load this instruction / offset
offset = jump_instructions[i]
# Modify current offset using the offset adjustment function
jump_instructions[i] += offset_adjustment_fn(offset)
# Adjust index by current offset
i += offset
steps_to_exit_instructions += 1
return steps_to_exit_instructions
return steps_required_to_reach_exit(input_instructions, lambda x: 1), \
steps_required_to_reach_exit(input_instructions, lambda x: -1 if x >= 3 else 1)
def solve():
"""Advent Of Code 2017 - Day 10 Solution.
:return: tuple(part_a_result[int], part_b_result[int])
"""
puzzle_input = read_puzzle_input(
os.path.dirname(os.path.abspath(__file__)),
"day_10_input.txt")[0].strip()
puzzle_knots = [i for i in range(256)]
part_a_input = tuple(
int(input_number) for input_number in puzzle_input.split(","))
part_a_hashed = knot_hash_n_times(puzzle_knots, part_a_input, 1)
part_a_result = part_a_hashed[0] * part_a_hashed[1]
part_b_lengths = tuple(ord(char)
for char in puzzle_input) + (17, 31, 73, 47, 23)
part_b_knot_hash = knot_hash_n_times(puzzle_knots, part_b_lengths, 64)
part_b_dense_hash = dense_hash(part_b_knot_hash, 16)
part_b_result = ''.join(
['{:02x}'.format(num_to_hex) for num_to_hex in part_b_dense_hash])
return part_a_result, part_b_result
def solve():
"""Advent Of Code 2017 - Day 16 Solution.
:return: tuple(part_a_result[int], part_b_result[int])
"""
def dance_n_times(dance_moves, times):
programs_init = [char for char in char_range('a', 'p')]
seen_states = []
dlist = DancingList(programs_init)
for time in range(times):
seen_hash = ''.join(dlist.get_values())
if seen_hash in seen_states:
return (seen_states[times % time])
seen_states.append(seen_hash)
for dance_move in dance_moves:
if dance_move.startswith("s"):
dance_move = dance_move[1:]
dlist.spin(int(dance_move))
elif dance_move.startswith("x"):
dance_move = dance_move[1:]
idx_a, idx_b = map(int, dance_move.split("/"))
dlist.swap_index(idx_a, idx_b)
elif dance_move.startswith("p"):
dance_move = dance_move[1:]
member_a, member_b = dance_move.split("/")
dlist.swap_member(member_a, member_b)
return ''.join(dlist.get_values())
puzzle_input = read_puzzle_input(os.path.dirname(os.path.abspath(__file__)), "day_16_input.txt")[0].split(",")
return dance_n_times(puzzle_input, 1), dance_n_times(puzzle_input, 1000000000)
def solve():
"""Advent Of Code 2017 - Day 14 Solution.
:return: tuple(part_a_result[int], part_b_result[int])
"""
puzzle_input = read_puzzle_input(
os.path.dirname(os.path.abspath(__file__)), "day_14_input.txt")[0]
C_FULL = "1" # Constant for full disk block
C_EMPTY = "0" # Constant for empty disk block
def get_knot_hash(input_string):
# Initialize 256 knots, just like on day_10 part-B
puzzle_knots = [i for i in range(256)]
# Calculate lengths based on input + (17, 31, 73, 47, 23), just like on day_10 part-B
lengths = tuple(ord(char)
for char in input_string) + (17, 31, 73, 47, 23)
# Get knot hash, by applying 64 transformations, just like on day_10 part-B
knot_hash = day_10.knot_hash_n_times(puzzle_knots, lengths, 64)
# Get dense hash of length 16, just like on day_10 part-B
dense_hash = day_10.dense_hash(knot_hash, 16)
# Transform dense hash into string of hexadecimal characters, just like on day_10 part-B
hex_hash = ''.join(
['{:02x}'.format(num_to_hex) for num_to_hex in dense_hash])
return hex_hash
def convert_hex_to_bin(hash_hex):
binary_string = ""
for char in hash_hex:
binary_string += "{:04b}".format(int(char, base=16))
return binary_string
# Store disk representation in memory
disk = []
for row in range(0, 128):
current_row_hash = get_knot_hash(puzzle_input + "-" + str(row))
current_row_bin = convert_hex_to_bin(current_row_hash)
disk.append(list(current_row_bin))
def solve_a():
"""Advent Of Code 2017 - Day 14 - Part A Solution.
"""
space_used = 0 # Answer for part-A
for row in range(len(disk)):
for col in range(len(disk[row])):
if disk[row][col] == C_FULL:
space_used += 1
return space_used
def solve_b():
"""Advent Of Code 2017 - Day 14 - Part B Solution.
"""
regions = 0 # Answer for part-B
def clean_block(row, col):
# Empty out current block and all adjacent blocks (if current block isn't empty)
if disk[row][col] == C_FULL:
disk[row][col] = C_EMPTY
# Empty out block on same Y-position, on previous row (if we're not at top edge)
if row > 0:
clean_block(row - 1, col)
# Empty out block on same Y-position, on following row (if we're not at bottom edge)
if row < len(disk) - 1:
clean_block(row + 1, col)
# Empty out block on X-1 position of the same row (if we're not at left edge)
if col > 0:
clean_block(row, col - 1)
# Empty out block on X+1 position of the same row (if we're not at right edge)
if col < len(disk[row]) - 1:
clean_block(row, col + 1)
for row in range(len(disk)):
for col in range(len(disk[row])):
# If the block is full, increase number of regions and nuke the whole region
if disk[row][col] == C_FULL:
regions += 1
clean_block(row, col)
return regions
return solve_a(), solve_b()
def solve():
# Load instructions
for puzzle_input in read_puzzle_input(
os.path.dirname(os.path.abspath(__file__)), "puzzle11_input.txt"):
print("Puzzle11, part A:{}".format(solve_a(puzzle_input)))
print("Puzzle11, part B:{}".format(solve_a(solve_a(puzzle_input))))
