if way is None:
way = [1,0]
ship = [0,0]
for (act, off) in actions:
if act in DIR:
if anchor:
ship[DIR.index(act) // 2] += scale(act, off)
else:
way[DIR.index(act) // 2] += scale(act, off)
elif act == "F":
ship = [ship[0] + off*way[0], ship[1] + off*way[1]]
elif act in "RL":
ang = deg_rad(off) if act == "L" else -deg_rad(off)
way = rot(way, ang)
return abs(ship[0]) + abs(ship[1])
# Separate actions from offsets.
ACTION_REG = r"(\w{1})(\d+)"
if __name__ == "__main__":
usage_and_exit(len(argv) != 2)
input_data = regex(arrange(open_file(argv[1])), (str, int), ACTION_REG)
print(solve(input_data))
print(solve(input_data, [10,1], False))
if elem not in two_sum(lst[i:pre + i]):
bad_elem = elem
return bad_elem
# Cumulatively sum all elements of the list <ls> through <i>.
cum_sum = lambda ls, i: sum(ls[:i + 1])
def solve2(lst, k):
"""Find in a list <lst> a group of any size whose sum equals <k>."""
for i in range(len(lst)):
for j in range(len(lst)):
if i > j and cum_sum(lst, i) - cum_sum(lst, j) == k:
part = lst[j + 1:i + 1]
return min(part) + max(part)
return None
if __name__ == "__main__":
usage_and_exit(len(argv) != 2)
input_data = arrange(open_file(argv[1]), int)
print(sol1 := solve1(input_data, 25))
print(solve2(input_data, sol1))
def solve(seats):
"""Find the missing seat from the occupied <seats>.
I used my own implementation of insertion sort to solve this one. """
sort_s = [False] * 2**10
for i in seats:
sort_s[i] = True
our_s = 0
for i, _ in enumerate(sort_s):
if not sort_s[i] and sort_s[i - 1] and sort_s[i + 1]:
our_s = i
break
return our_s
# Transform the seat ID <s> in a binary number.
binnum = lambda s: int(sub("(?:F|L)", "0", sub("(?:B|R)", "1", s)), 2)
if __name__ == "__main__":
usage_and_exit(len(argv) != 2)
input_data = [binnum(seat) for seat in arrange(open_file(argv[1]))]
print(solve(input_data))
"""Find the smallest timestamp, such that all the <buses> follow their
bus ID, which is indexically paired with <depart>.
Here I used the Chinese Remainder Theorem, someone well acquainted to
anyone who does competitive or discrete mathematics. """
# Desired residue class for each bus.
mods = [(b - d) % b for b, d in zip(buses, depart)]
# Cross multiplication of the elements in the sequence.
cross_mul = [product(buses) // b for b in buses]
return sum(
[c * pow(c, -1, b) * m
for b, c, m in zip(buses, cross_mul, mods)]) % product(buses)
if __name__ == "__main__":
usage_and_exit(len(argv) != 2)
input_file = arrange(open_file(argv[1]))
bus_data = [int(b) for b in findall(r"\d+", input_file[1])]
estimate = int(input_file[0])
depart_data = [
i for i, d in enumerate(findall(r"\w+", input_file[1])) if d != "x"
]
print(solve1(bus_data, estimate))
print(solve2(bus_data, depart_data))
prev = deepcopy(current)
whites = ground(current)
for black in prev:
neigh_b = count_neighbours(prev, black)
if neigh_b not in [1,2]:
current.remove(black)
for white in whites:
neigh_w = count_neighbours(prev, white)
if neigh_w == 2:
current.add(white)
return current
# Extract the individual cardinals from the direction.
CARD_REG = r"(ne|nw|se|sw|e|w)"
if __name__ == "__main__":
usage_and_exit(len(argv) != 2)
input_data = [findall(CARD_REG, tile)
for tile in arrange(open_file(argv[1]))]
print(len(sol := solve1(input_data)))
print(len(solve2(sol, 100)))
count = 0
for edge in edges(bags):
if edge[0] == elem:
count += edge[1][0] * solve2(bags, edge[1][1]) + edge[1][0]
return count
# Capture the bag name and its contents (ignoring weights).
UNWEIGHTED_REG = r"(?:^|\d+ ?)(.+?) bags?"
# Capture the bag's contents and its weights.
WEIGHTED_REG = r"(\d+) (.+?) bags?"
# Capture the bag name.
VERTEX_REG = r"^(.+?) bags"
if __name__ == "__main__":
usage_and_exit(len(argv) != 2)
arranged_data = arrange(open_file(argv[1]))
unweighted_data = merge([dictf(findall(UNWEIGHTED_REG, f))
for f in arranged_data])
weighted_data = merge([dictf(findall(VERTEX_REG, f) + transfiged
(findall(WEIGHTED_REG, f), (int, str)))
for f in arranged_data])
print(len(solve1(unweighted_data, "shiny gold")))
print(solve2(weighted_data, "shiny gold"))
KEY_VAL_REG = r"(\w{3}):(.+?)(?:\s|$)"
REQ_KEYS = {"byr", "iyr", "eyr", "hgt", "hcl", "ecl", "pid"}
def solve(passes, rules=None):
"""Validate the passports <passes> according to <rules> and check the
required fields (<REQ_KEYS>); if no <rules> are provided, check only
the required fields. """
valid = 0
for pasp in passes:
# Dictionary association with {key: value}.
soc = dict(findall(KEY_VAL_REG, pasp))
keys = set(findall(KEY_REG, pasp))
if keys.issuperset(REQ_KEYS) \
and (rules is None or assoc(soc, rules)):
valid += 1
return valid
if __name__ == "__main__":
usage_and_exit(len(argv) != 2)
input_data = arrange(open_file(argv[1]), sep="\n\n")
print(solve(input_data))
print(solve(input_data, RULEBOOK))
card2 = deck2[0]
deck1 = deck1[1:]
deck2 = deck2[1:]
if len(deck1) >= card1 and len(deck2) >= card2 and recursive:
sub_deck1 = deepcopy(deck1)[:card1]
sub_deck2 = deepcopy(deck2)[:card2]
player1_has_won = solve(sub_deck1, sub_deck2, recursive)[1]
else:
player1_has_won = card1 > card2
if player1_has_won:
deck1 += [card1, card2]
else:
deck2 += [card2, card1]
return (get_score(deck1) if player1_has_won else get_score(deck2),
player1_has_won)
if __name__ == "__main__":
usage_and_exit(len(argv) != 2)
arranged_data = arrange(open_file(argv[1]), sep="\n\n")
deck_data = [[int(j) for j in arrange(i)[1:]] for i in arranged_data]
print(solve(deck_data[0], deck_data[1])[0])
print(solve(deck_data[0], deck_data[1], True)[0])
changed = False
neighbours = [[
count_neighbours(current, (row, seat), adjacent)
for seat in range(len(current[0]))
] for row in range(len(current))]
for i, row in enumerate(current):
for j, seat in enumerate(row):
if seat == State.FREE.value and neighbours[i][j] == 0:
current[i][j] = State.OCC.value
changed = True
elif seat == State.OCC.value \
and neighbours[i][j] >= threshold:
current[i][j] = State.FREE.value
changed = True
return sum([row.count(State.OCC.value) for row in current])
# Replace all the symbols in <st> with numbers.
enumer = lambda st: sub(r"[.]", "2", sub(r"#", "1", sub(r"L", "0", st)))
if __name__ == "__main__":
usage_and_exit(len(argv) != 2)
input_data = [[int(i) for i in list(enumer(row))]
for row in arrange(open_file(argv[1]))]
print(solve(input_data, 4))
print(solve(input_data, 5, False))
