Skip to content

Commit d1afc54

Browse files
PiratmacPiratmac
committed
Added days 2016-21 to 2016-25, plus a few fixes
1 parent d68ad2b commit d1afc54

7 files changed

+630
-2
lines changed

‎2016/17-Two Steps Forward.py

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -72,7 +72,7 @@ def neighbors (self, vertex):
7272

7373
vault = pathfinding.Graph([((0, 0), '')])
7474

75-
vault.breath_first_search(((0, 0), ''))
75+
vault.breadth_first_search(((0, 0), ''))
7676

7777
if part_to_test == 1:
7878
for vertex in vault.vertices:

‎2016/21-Scrambled Letters and Hash.py

Lines changed: 111 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,111 @@
1+
# -------------------------------- Input data -------------------------------- #
2+
import os, itertools
3+
4+
test_data = {}
5+
6+
test = 1
7+
test_data[test] = {"input": ('abcde', """swap position 4 with position 0
8+
swap letter d with letter b
9+
reverse positions 0 through 4
10+
rotate left 1 step
11+
move position 1 to position 4
12+
move position 3 to position 0
13+
rotate based on position of letter b
14+
rotate based on position of letter d"""),
15+
"expected": ['Unknown', 'Unknown'],
16+
}
17+
18+
test += 1
19+
test_data[test] = {"input": """""",
20+
"expected": ['Unknown', 'Unknown'],
21+
}
22+
23+
test = 'real'
24+
input_file = os.path.join(os.path.dirname(__file__), 'Inputs', os.path.basename(__file__).replace('.py', '.txt'))
25+
test_data[test] = {"input": ('abcdefgh', open(input_file, "r+").read().strip()),
26+
"expected": ['bgfacdeh', 'bdgheacf'],
27+
}
28+
29+
# -------------------------------- Control program execution -------------------------------- #
30+
31+
case_to_test = 'real'
32+
part_to_test = 2
33+
verbose_level = 1
34+
35+
# -------------------------------- Initialize some variables -------------------------------- #
36+
37+
puzzle_input = test_data[case_to_test]['input']
38+
puzzle_expected_result = test_data[case_to_test]['expected'][part_to_test-1]
39+
puzzle_actual_result = 'Unknown'
40+
41+
42+
# -------------------------------- Actual code execution -------------------------------- #
43+
44+
45+
def scramble_password (puzzle_input):
46+
password = puzzle_input[0]
47+
for string in puzzle_input[1].split('\n'):
48+
if string[0:13] == 'swap position':
49+
_, _, x, _, _, y = string.split(' ')
50+
x, y = int(x), int(y)
51+
x, y = min(x, y), max(x, y)
52+
new_password = password[0:x] + password[y] + password[x+1:y] + password[x] + password[y+1:]
53+
elif string[0:11] == 'swap letter':
54+
_, _, x, _, _, y = string.split(' ')
55+
new_password = password.replace(x, '#').replace(y, x).replace('#', y)
56+
elif string[0:12] == 'rotate based':
57+
_, _, _, _, _, _, letter = string.split(' ')
58+
position = password.find(letter)
59+
if position >= 4:
60+
position += 2
61+
else:
62+
position += 1
63+
new_password = password[-position%len(password):] + password[0:-position%len(password)]
64+
elif string[0:17] == 'reverse positions':
65+
_, _, x, _, y = string.split(' ')
66+
x, y = int(x), int(y)
67+
new_password = password[0:x] + password[y:x:-1] + password[x] + password[y+1:]
68+
elif string[0:13] == 'move position':
69+
_, _, x, _, _, y = string.split(' ')
70+
x, y = int(x), int(y)
71+
if x < y:
72+
new_password = password[0:x] + password[x+1:y+1] + password[x] + password[y+1:]
73+
else:
74+
new_password = password[0:y] + password[x] + password[y:x] + password[x+1:]
75+
else:
76+
_, direction, x, _ = string.split(' ')
77+
x = int(x)
78+
if direction == 'left':
79+
new_password = password[x:] + password[0:x]
80+
else:
81+
new_password = password[len(password)-x:] + password[0:len(password)-x]
82+
password = new_password
83+
# print (string, password)
84+
return password
85+
86+
if part_to_test == 1:
87+
puzzle_actual_result = scramble_password(puzzle_input)
88+
89+
90+
else:
91+
for combination in itertools.permutations('abcdefgh'):
92+
password = ''.join(combination)
93+
scrambled = scramble_password((password, puzzle_input[1]))
94+
print (password, scrambled)
95+
if scrambled == 'fbgdceah':
96+
puzzle_actual_result = password
97+
break
98+
99+
100+
101+
102+
# -------------------------------- Outputs / results -------------------------------- #
103+
104+
if verbose_level >= 3:
105+
print ('Input : ' + puzzle_input)
106+
print ('Expected result : ' + str(puzzle_expected_result))
107+
print ('Actual result : ' + str(puzzle_actual_result))
108+
109+
110+
111+

‎2016/22-Grid Computing.py

Lines changed: 87 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,87 @@
1+
# -------------------------------- Input data -------------------------------- #
2+
import os
3+
4+
test_data = {}
5+
6+
test = 1
7+
test_data[test] = {"input": """""",
8+
"expected": ['Unknown', 'Unknown'],
9+
}
10+
11+
test += 1
12+
test_data[test] = {"input": """""",
13+
"expected": ['Unknown', 'Unknown'],
14+
}
15+
16+
test = 'real'
17+
input_file = os.path.join(os.path.dirname(__file__), 'Inputs', os.path.basename(__file__).replace('.py', '.txt'))
18+
test_data[test] = {"input": open(input_file, "r+").read().strip(),
19+
"expected": ['946', '195'],
20+
}
21+
22+
# -------------------------------- Control program execution -------------------------------- #
23+
24+
case_to_test = 'real'
25+
part_to_test = 2
26+
verbose_level = 1
27+
28+
# -------------------------------- Initialize some variables -------------------------------- #
29+
30+
puzzle_input = test_data[case_to_test]['input']
31+
puzzle_expected_result = test_data[case_to_test]['expected'][part_to_test-1]
32+
puzzle_actual_result = 'Unknown'
33+
34+
35+
# -------------------------------- Actual code execution -------------------------------- #
36+
37+
if part_to_test == 1:
38+
nodes_used = {}
39+
nodes_avail = {}
40+
for string in puzzle_input.split('\n'):
41+
if string == '':
42+
continue
43+
if string[0] != '/':
44+
continue
45+
46+
string = string.replace(' ', ' ').replace(' ', ' ').replace(' ', ' ')
47+
name, size, used, avail, use = string.split (' ')
48+
used, avail = int(used[:-1]), int(avail[:-1])
49+
nodes_used[name] = used
50+
nodes_avail[name] = avail
51+
52+
count_pairs = 0
53+
for node, used in nodes_used.items():
54+
if used == 0:
55+
continue
56+
count_pairs += len([name for name, avail in nodes_avail.items() if name != node and used <= avail])
57+
58+
puzzle_actual_result = count_pairs
59+
60+
61+
62+
63+
else:
64+
# All small nodes can contain the data of all other small nodes
65+
# Very large nodes can't contain more data, and can't transfer their data
66+
# So, basically, they are walls
67+
# There is one empty node
68+
# That node is basically the "player" which moves around
69+
# It takes 45 moves for that player to move left to the goal, and for the goal to move to that player
70+
# Then, it takes 5 moves for the player to go around the goal, then for the goal to move to the player
71+
# So, every movement to the left takes 5 moves
72+
# There are 30 leftbound moved to make (first one is included in the 45):
73+
puzzle_actual_result = 45 + 5*30
74+
75+
76+
77+
78+
# -------------------------------- Outputs / results -------------------------------- #
79+
80+
if verbose_level >= 3:
81+
print ('Input : ' + puzzle_input)
82+
print ('Expected result : ' + str(puzzle_expected_result))
83+
print ('Actual result : ' + str(puzzle_actual_result))
84+
85+
86+
87+

‎2016/23-Safe Cracking.py

Lines changed: 151 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,151 @@
1+
# -------------------------------- Input data -------------------------------- #
2+
import os
3+
4+
test_data = {}
5+
6+
test = 1
7+
test_data[test] = {"input": """cpy 2 a
8+
tgl a
9+
tgl a
10+
tgl a
11+
cpy 1 a
12+
dec a
13+
dec a""",
14+
"expected": ['3', 'Unknown'],
15+
}
16+
17+
test += 1
18+
test_data[test] = {"input": """""",
19+
"expected": ['Unknown', 'Unknown'],
20+
}
21+
22+
test = 'real'
23+
input_file = os.path.join(os.path.dirname(__file__), 'Inputs', os.path.basename(__file__).replace('.py', '.txt'))
24+
test_data[test] = {"input": open(input_file, "r+").read().strip(),
25+
"expected": ['10886', '479007446'],
26+
}
27+
28+
# -------------------------------- Control program execution -------------------------------- #
29+
30+
case_to_test = 'real'
31+
part_to_test = 1
32+
verbose_level = 1
33+
34+
35+
def RepresentsInt(s):
36+
try:
37+
int(s)
38+
return True
39+
except ValueError:
40+
return False
41+
42+
# -------------------------------- Initialize some variables -------------------------------- #
43+
44+
puzzle_input = test_data[case_to_test]['input']
45+
puzzle_expected_result = test_data[case_to_test]['expected'][part_to_test-1]
46+
puzzle_actual_result = 'Unknown'
47+
48+
49+
# -------------------------------- Actual code execution -------------------------------- #
50+
registers = {'a':0, 'b':0, 'c':0, 'd':0}
51+
52+
instructions = puzzle_input.split('\n')
53+
i = 0
54+
if case_to_test == 'real':
55+
if part_to_test == 1:
56+
registers['a'] = 7
57+
else:
58+
registers['a'] = 12
59+
60+
while True:
61+
instruction = instructions[i]
62+
i += 1
63+
64+
# print (i, instruction, registers)
65+
66+
if instruction[0:3] == 'cpy':
67+
_, val, target = instruction.split(' ')
68+
try:
69+
registers[target] = int(val)
70+
except ValueError:
71+
registers[target] = registers[val]
72+
73+
elif instruction[0:3] == 'inc':
74+
_, target = instruction.split(' ')
75+
if target in registers:
76+
registers[target] += 1
77+
elif instruction[0:3] == 'dec':
78+
_, target = instruction.split(' ')
79+
if target in registers:
80+
registers[target] -= 1
81+
82+
elif instruction[0:3] == 'tgl':
83+
_, target = instruction.split(' ')
84+
target = registers[target]
85+
86+
target_position = i+target-1 # -1 because we added 1 to i before
87+
if target_position < len(instructions):
88+
89+
if instructions[target_position][0:3] == 'inc':
90+
instructions[target_position] = 'dec' + instructions[target_position][3:]
91+
elif instructions[target_position][0:3] == 'dec':
92+
instructions[target_position] = 'inc' + instructions[target_position][3:]
93+
elif instructions[target_position][0:3] == 'jnz':
94+
instructions[target_position] = 'cpy' + instructions[target_position][3:]
95+
elif instructions[target_position][0:3] == 'cpy':
96+
instructions[target_position] = 'jnz' + instructions[target_position][3:]
97+
elif instructions[target_position][0:3] == 'tgl':
98+
instructions[target_position] = 'inc' + instructions[target_position][3:]
99+
100+
elif instruction[0:3] == 'jnz':
101+
_, target, jump = instruction.split(' ')
102+
if target == '0':
103+
pass
104+
else:
105+
if RepresentsInt(target) and RepresentsInt(jump):
106+
i = i + int(jump) - 1 # -1 to compensate for what we added before
107+
elif RepresentsInt(target):
108+
i = i + registers[jump] - 1 # -1 to compensate for what we added before
109+
elif RepresentsInt(jump):
110+
if registers[target] != 0:
111+
i = i + int(jump) - 1 # -1 to compensate for what we added before
112+
113+
elif instruction[0:3] == 'add':
114+
_, source, target = instruction.split(' ')
115+
if source == '0':
116+
pass
117+
else:
118+
if RepresentsInt(source):
119+
registers[target] += int(source)
120+
else:
121+
registers[target] += registers[source]
122+
123+
elif instruction[0:3] == 'mul':
124+
_, source, target = instruction.split(' ')
125+
if source == '0':
126+
pass
127+
else:
128+
if RepresentsInt(source):
129+
registers[target] *= int(source)
130+
else:
131+
registers[target] *= registers[source]
132+
133+
if i >= len(instructions):
134+
break
135+
136+
puzzle_actual_result = registers['a']
137+
138+
139+
140+
141+
142+
# -------------------------------- Outputs / results -------------------------------- #
143+
144+
if verbose_level >= 3:
145+
print ('Input : ' + puzzle_input)
146+
print ('Expected result : ' + str(puzzle_expected_result))
147+
print ('Actual result : ' + str(puzzle_actual_result))
148+
149+
150+
151+

0 commit comments

Comments
 (0)
pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy