Update things

Author: XHRogerCao

09-01.py

@@ -0,0 +1,27 @@
+head = (0, 0)
+tail = (0, 0)
+visited = {(0, 0)}
+deltas = {
+    'U': [0, 1],
+    'D': [0, -1],
+    'L': [-1, 0],
+    'R': [1, 0]
+}
+def sign(n):
+    if n > 0:
+        return 1
+    if n < 0:
+        return -1
+    return 0
+while True:
+    inputval = input()
+    if inputval == "": break
+    dir, moves = inputval.split()
+    moves = int(moves)
+    for i in range(moves):
+        head = (deltas[dir][0] + head[0], deltas[dir][1] + head[1])
+        diff = (head[0] - tail[0], head[1] - tail[1])
+        if abs(diff[0]) >= 2 or abs(diff[1]) >= 2:
+            tail = (tail[0] + sign(diff[0]), tail[1] + sign(diff[1]))
+        visited.add(tail)
+print(len(visited))

09-02.py

@@ -0,0 +1,29 @@
+rope = []
+for i in range(10):
+    rope.append((0, 0))
+visited = {(0, 0)}
+deltas = {
+    'U': [0, 1],
+    'D': [0, -1],
+    'L': [-1, 0],
+    'R': [1, 0]
+}
+def sign(n):
+    if n > 0:
+        return 1
+    if n < 0:
+        return -1
+    return 0
+while True:
+    inputval = input()
+    if inputval == "": break
+    dir, moves = inputval.split()
+    moves = int(moves)
+    for i in range(moves):
+        rope[0] = (deltas[dir][0] + rope[0][0], deltas[dir][1] + rope[0][1])
+        for j in range(9):
+            diff = (rope[j][0] - rope[j + 1][0], rope[j][1] - rope[j + 1][1])
+            if abs(diff[0]) >= 2 or abs(diff[1]) >= 2:
+                rope[j + 1] = (rope[j + 1][0] + sign(diff[0]), rope[j + 1][1] + sign(diff[1]))
+        visited.add(rope[-1])
+print(len(visited))

10-01.py

@@ -0,0 +1,22 @@
+register = 1
+score = 0
+cycle_num = 0
+cycles = [220, 180, 140, 100, 60, 20]
+while True:
+    inputval = input()
+    if inputval == '': break
+    inputvals = inputval.split()
+    if inputvals[0] == 'noop':
+        cycle_num += 1
+        if cycles and cycle_num >= cycles[-1]:
+            score += cycles[-1] * register
+            print(cycles[-1] * register)
+            cycles.pop()
+    else:
+        cycle_num += 2
+        if cycles and cycle_num >= cycles[-1]:
+            score += cycles[-1] * register
+            print(cycles[-1] * register)
+            cycles.pop()
+        register += int(inputvals[1])
+print(score)

10-02.py

@@ -0,0 +1,29 @@
+register = 1
+cycle_num = 0
+cycles = 40
+crtOutput = ""
+def outputPixel():
+    global crtOutput
+    if abs(register - cycle_num) <= 1:
+        crtOutput += '#'
+    else:
+        crtOutput += '.'
+while True:
+    inputval = input()
+    if inputval == '': break
+    inputvals = inputval.split()
+    if inputvals[0] == 'noop':
+        outputPixel()
+        cycle_num += 1
+        if cycles and cycle_num >= cycles:
+            cycle_num = 0
+            crtOutput += '\n'
+    else:
+        for i in range(2):
+            outputPixel()
+            cycle_num += 1
+            if cycles and cycle_num >= cycles:
+                cycle_num = 0
+                crtOutput += '\n'
+        register += int(inputvals[1])
+print(crtOutput)

11-01.py

@@ -0,0 +1,53 @@
+class Monkey:
+    def __init__(self, items = None, transition = None, test = None, ifTrue = None, ifFalse = None) -> None:
+        self.items = items
+        self.transition = transition
+        self.test = test
+        self.ifTrue = ifTrue
+        self.ifFalse = ifFalse
+
+monkeys = []
+
+def make_lambda(op, val):
+    if op == "+":
+        return lambda old: old + (old if val == "old" else int(val))
+    else:
+        return lambda old: old * (old if val == "old" else int(val))
+
+while True:
+    inputval = input()
+    if inputval == "": break
+    monkey = Monkey()
+    monkey.items = list(map(lambda x: int(x), input()[18:].split(", ")))
+    newFunc = input()[23:].split()
+    monkey.transition = make_lambda(*newFunc)
+    monkey.test = int(input()[21:])
+    monkey.ifTrue = int(input()[29:])
+    monkey.ifFalse = int(input()[30:])
+    monkeys.append(monkey)
+    input()
+
+inspections = [0] * len(monkeys)
+
+for i in range(20):
+    print(f"Round {i+1}:")
+    for j in range(len(monkeys)):
+        print(f"  Monkey {j}:")
+        monkey = monkeys[j]
+        for item in monkey.items:
+            print(f"    Item {item}:", end='')
+            item = monkey.transition(item)
+            print(f" New score={item};", end='')
+            item = item // 3
+            print(f" New score={item};", end='')
+            inspections[j] += 1
+            if item % monkey.test == 0:
+                monkeys[monkey.ifTrue].items.append(item)
+                print(f" True, to monkey {monkey.ifTrue}")
+            else:
+                monkeys[monkey.ifFalse].items.append(item)
+                print(f" False, to monkey {monkey.ifFalse}")
+        monkey.items.clear()
+print(inspections)
+inspections.sort()
+print(inspections[-1] * inspections[-2])

11-02.py

@@ -0,0 +1,51 @@
+class Monkey:
+    def __init__(self, items = None, transition = None, test = None, ifTrue = None, ifFalse = None) -> None:
+        self.items = items
+        self.transition = transition
+        self.test = test
+        self.ifTrue = ifTrue
+        self.ifFalse = ifFalse
+
+monkeys = []
+
+def make_lambda(op, val):
+    if op == "+":
+        return lambda old: old + (old if val == "old" else int(val))
+    else:
+        return lambda old: old * (old if val == "old" else int(val))
+
+while True:
+    inputval = input()
+    if inputval == "": break
+    monkey = Monkey()
+    monkey.items = list(map(lambda x: int(x), input()[18:].split(", ")))
+    newFunc = input()[23:].split()
+    monkey.transition = make_lambda(*newFunc)
+    monkey.test = int(input()[21:])
+    monkey.ifTrue = int(input()[29:])
+    monkey.ifFalse = int(input()[30:])
+    monkeys.append(monkey)
+    input()
+
+inspections = [0] * len(monkeys)
+
+lcmVal = 1
+
+# Manually check that the monkeys have prime test values
+for monkey in monkeys:
+    lcmVal = lcmVal * monkey.test
+
+for i in range(10000):
+    for j in range(len(monkeys)):
+        monkey = monkeys[j]
+        for item in monkey.items:
+            item = monkey.transition(item) % lcmVal
+            inspections[j] += 1
+            if item % monkey.test == 0:
+                monkeys[monkey.ifTrue].items.append(item)
+            else:
+                monkeys[monkey.ifFalse].items.append(item)
+        monkey.items.clear()
+print(inspections)
+inspections.sort()
+print(inspections[-1] * inspections[-2])

12-01.py

@@ -0,0 +1,33 @@
+from collections import deque
+
+height_map = []
+min_dist = []
+bfs_queue = deque()
+target_location = None
+while True:
+    inputval = input()
+    if inputval == "": break
+    height_map.append([])
+    min_dist.append([])
+    for i in range(len(inputval)):
+        if inputval[i] == 'S':
+            height_map[-1].append(1)
+            min_dist[-1].append(0)
+            bfs_queue.append((len(height_map) - 1, i))
+        elif inputval[i] == 'E':
+            height_map[-1].append(26)
+            min_dist[-1].append(-1)
+            target_location = (len(height_map) - 1, i)
+        else:
+            height_map[-1].append(ord(inputval[i]) - ord('a') + 1)
+            min_dist[-1].append(-1)
+dirs = [(0, 1), (0, -1), (1, 0), (-1, 0)]
+while min_dist[target_location[0]][target_location[1]] == -1:
+    row, col = bfs_queue.popleft()
+    for rowDelta, colDelta in dirs:
+        newRow, newCol = row + rowDelta, col + colDelta
+        if newRow >= 0 and newRow < len(height_map) and newCol >= 0 and newCol < len(height_map[newRow]):
+            if min_dist[newRow][newCol] == -1 and height_map[newRow][newCol] - height_map[row][col] <= 1:
+                min_dist[newRow][newCol] = min_dist[row][col] + 1
+                bfs_queue.append((newRow, newCol))
+print(min_dist[target_location[0]][target_location[1]])

12-02.py

@@ -0,0 +1,33 @@
+from collections import deque
+
+height_map = []
+min_dist = []
+bfs_queue = deque()
+target_location = None
+while True:
+    inputval = input()
+    if inputval == "": break
+    height_map.append([])
+    min_dist.append([])
+    for i in range(len(inputval)):
+        if inputval[i] == 'S' or inputval[i] == 'a':
+            height_map[-1].append(1)
+            min_dist[-1].append(0)
+            bfs_queue.append((len(height_map) - 1, i))
+        elif inputval[i] == 'E':
+            height_map[-1].append(26)
+            min_dist[-1].append(-1)
+            target_location = (len(height_map) - 1, i)
+        else:
+            height_map[-1].append(ord(inputval[i]) - ord('a') + 1)
+            min_dist[-1].append(-1)
+dirs = [(0, 1), (0, -1), (1, 0), (-1, 0)]
+while min_dist[target_location[0]][target_location[1]] == -1:
+    row, col = bfs_queue.popleft()
+    for rowDelta, colDelta in dirs:
+        newRow, newCol = row + rowDelta, col + colDelta
+        if newRow >= 0 and newRow < len(height_map) and newCol >= 0 and newCol < len(height_map[newRow]):
+            if min_dist[newRow][newCol] == -1 and height_map[newRow][newCol] - height_map[row][col] <= 1:
+                min_dist[newRow][newCol] = min_dist[row][col] + 1
+                bfs_queue.append((newRow, newCol))
+print(min_dist[target_location[0]][target_location[1]])

13-01.py

@@ -0,0 +1,28 @@
+left_signals = []
+right_signals = []
+while True:
+    inputval = input()
+    if inputval == "": break
+    left_signals.append(eval(inputval))
+    right_signals.append(eval(input()))
+    input()
+score = 0
+def compare_values(a, b):
+    if type(a) is int:
+        if type(b) is int:
+            return a - b
+        else:
+            return compare_values([a], b)
+    else:
+        if type(b) is int:
+            return compare_values(a, [b])
+        else:
+            for i in range(min(len(a), len(b))):
+                val = compare_values(a[i], b[i])
+                if val != 0:
+                    return val
+            return len(a) - len(b)
+for i in range(len(left_signals)):
+    if compare_values(left_signals[i], right_signals[i]) < 0:
+        score += i + 1
+print(score)

13-02.py

@@ -0,0 +1,31 @@
+import functools
+signals = [[[2]], [[6]]]
+while True:
+    inputval = input()
+    if inputval == "": break
+    signals.append(eval(inputval))
+    signals.append(eval(input()))
+    input()
+def compare_values(a, b):
+    if type(a) is int:
+        if type(b) is int:
+            return a - b
+        else:
+            return compare_values([a], b)
+    else:
+        if type(b) is int:
+            return compare_values(a, [b])
+        else:
+            for i in range(min(len(a), len(b))):
+                val = compare_values(a[i], b[i])
+                if val != 0:
+                    return val
+            return len(a) - len(b)
+signals.sort(key=functools.cmp_to_key(compare_values))
+
+score = 1
+
+for i in range(len(signals)):
+    if compare_values(signals[i], [[2]]) == 0 or compare_values(signals[i], [[6]]) == 0:
+        score = score * (i + 1)
+print(score)

14-01.py

@@ -0,0 +1,49 @@
+rocks = []
+while True:
+    inputval = input()
+    if inputval == "": break
+    rocks.append([tuple(int(x) for x in oneCoord.split(",")) for oneCoord in inputval.split(" -> ")])
+min_x = min(min(coord[0] for coord in line) for line in rocks)
+max_x = max(max(coord[0] for coord in line) for line in rocks)
+max_y = max(max(coord[1] for coord in line) for line in rocks)
+
+print(min_x, max_x, max_y)
+
+# 0 for air, 1 for stone, 2 for sand
+caveMap = [[0] * (max_y + 1) for i in range(min_x, max_x + 1)]
+
+for line in rocks:
+    for start, end in zip(line[:-1], line[1:]):
+        if start[0] < end[0]:
+            for i in range(start[0], end[0] + 1):
+                caveMap[i - min_x][start[1]] = 1
+        else:
+            for i in range(end[0], start[0] + 1):
+                caveMap[i - min_x][start[1]] = 1
+        if start[1] < end[1]:
+            for i in range(start[1], end[1] + 1):
+                caveMap[start[0] - min_x][i] = 1
+        else:
+            for i in range(end[1], start[1] + 1):
+                caveMap[start[0] - min_x][i] = 1
+
+score = 0
+while True:
+    sandX, sandY = 500, 0
+    while sandY < max_y and sandX > min_x and sandX < max_x:
+        if caveMap[sandX - min_x][sandY + 1] == 0:
+            sandY += 1
+        elif caveMap[sandX - min_x - 1][sandY + 1] == 0:
+            sandY += 1
+            sandX += -1
+        elif caveMap[sandX - min_x + 1][sandY + 1] == 0:
+            sandY += 1
+            sandX += 1
+        else:
+            caveMap[sandX - min_x][sandY] = 2
+            score += 1
+            break
+    if not (sandY < max_y and sandX > min_x and sandX < max_x):
+        # Reached the edge. Break
+        break
+print(score)