Reformat project

Author: Mrbzs

.gitignore

@@ -1 +1,2 @@
-.vscode/
+.vscode/
+.idea

2019/01/01.py

@@ -4,10 +4,12 @@
 lines = [line.rstrip('\n') for line in inputFile]
 inputFile.close()
 
-def partOne():
+
+def part_one():
     return sum([int(mass) // 3 - 2 for mass in lines])
 
-def partTwo():
+
+def part_two():
     total = 0
     for line in lines:
         mass = int(line)
@@ -16,5 +18,6 @@ def partTwo():
             total += mass
     return total
 
-print(f'Part one: {partOne()}')
-print(f'Part two: {partTwo()}')
+
+print(f'Part one: {part_one()}')
+print(f'Part two: {part_two()}')

2019/02/02.py

@@ -4,7 +4,8 @@
 program = [int(num) for num in inputFile.read().rstrip().split(',')]
 inputFile.close()
 
-def partOne(a, b):
+
+def part_one(a, b):
     arr = program[:]
     arr[1:3] = [a, b]
 
@@ -16,11 +17,13 @@ def partOne(a, b):
         else:
             return arr[0]
 
-def partTwo():
+
+def part_two():
     for noun in range(100):
         for verb in range(100):
-            if partOne(noun, verb) == 19690720:
+            if part_one(noun, verb) == 19690720:
                 return 100 * noun + verb
 
-print(f'Part one: {partOne(12, 2)}')
-print(f'Part two: {partTwo()}')
+
+print(f'Part one: {part_one(12, 2)}')
+print(f'Part two: {part_two()}')

2019/03/03.py

@@ -4,9 +4,10 @@
 lines = [line.rstrip('\n') for line in inputFile]
 inputFile.close()
 
+
 def solve():
     points = {}
-    partOne = partTwo = 0
+    part_one = part_two = 0
     for wire in range(2):
         steps = 0
         pos = [0, 0]
@@ -20,15 +21,16 @@ def solve():
                 if wire == 1:
                     if (pos[0], pos[1]) in points:
                         distance = abs(pos[0]) + abs(pos[1])
-                        totalSteps = points[(pos[0], pos[1])] + steps
-                        if partOne == 0 or distance < partOne:
-                            partOne = distance
-                        if partTwo == 0 or totalSteps < partTwo:
-                            partTwo = totalSteps
+                        total_steps = points[(pos[0], pos[1])] + steps
+                        if part_one == 0 or distance < part_one:
+                            part_one = distance
+                        if part_two == 0 or total_steps < part_two:
+                            part_two = total_steps
                 else:
                     points[(pos[0], pos[1])] = steps
 
-    print(f'Part one: {partOne}')
-    print(f'Part two: {partTwo}')
+    print(f'Part one: {part_one}')
+    print(f'Part two: {part_two}')
+
 
 solve()

2019/04/04.py

@@ -7,11 +7,15 @@
 
 start, end = [int(num) for num in line.split('-')]
 
-def partOne():
-    return sum([re.match(r'^1*2*3*4*5*6*7*8*9*$', str(i)) != None and re.search(r'(.)\1', str(i)) != None for i in range(start, end + 1)])
 
-def partTwo():
-    return sum([re.match(r'^1*2*3*4*5*6*7*8*9*$', str(i)) != None and re.search(r'(.)\1(?<!\1..)(?!\1)', str(i)) != None for i in range(start, end + 1)])
+def part_one():
+    return sum([re.match(r'^1*2*3*4*5*6*7*8*9*$', str(i)) is not None and re.search(r'(.)\1', str(i)) is not None for i in range(start, end + 1)])
 
-print(f'Part one: {partOne()}')
-print(f'Part two: {partTwo()}')
+
+def part_two():
+    return sum([re.match(r'^1*2*3*4*5*6*7*8*9*$', str(i)) is not None and re.search(r'(.)\1(?<!\1..)(?!\1)', str(i)) is not None for i in
+                range(start, end + 1)])
+
+
+print(f'Part one: {part_one()}')
+print(f'Part two: {part_two()}')

2019/05/05.py

@@ -4,7 +4,8 @@
 line = inputFile.read().rstrip()
 inputFile.close()
 
-def partOne():
+
+def part_one():
     program = [int(i) for i in line.split(',')]
     output = i = 0
     while i < len(program):
@@ -23,7 +24,8 @@ def partOne():
             program[program[i + 3]] = p1 + p2 if instruction[-1] == '1' else p1 * p2
             i += 4
 
-def partTwo():
+
+def part_two():
     program = [int(i) for i in line.split(',')]
     output = i = 0
     while i < len(program):
@@ -56,5 +58,6 @@ def partTwo():
                 program[program[i + 3]] = 1 if p1 == p2 else 0
                 i += 4
 
-print(f'Part one: {partOne()}')
-print(f'Part two: {partTwo()}')
+
+print(f'Part one: {part_one()}')
+print(f'Part two: {part_two()}')

2019/06/06.py

@@ -5,15 +5,16 @@
 lines = inputFile.readlines()
 inputFile.close()
 
-def partOne():
+
+def part_one():
     # Performs recursive DFS
-    def getOrbits(orbited, orbits):
+    def get_orbits(orbited, orbits):
         if orbited not in graph:
             return 0
         total = 0
         orbits += 1
         for orbiter in graph[orbited]:
-            total += orbits + getOrbits(orbiter, orbits)
+            total += orbits + get_orbits(orbiter, orbits)
         return total
 
     # Construct directed graph
@@ -25,9 +26,10 @@ def getOrbits(orbited, orbits):
         else:
             graph[orbited] = [orbiter[:-1]]
 
-    return getOrbits('COM', 0)
+    return get_orbits('COM', 0)
+
 
-def partTwo():
+def part_two():
     # Construct undirected graph
     graph = {}
     start = destination = ''
@@ -51,20 +53,21 @@ def partTwo():
     distances = {start: 0}
     visited = {}
     while len(visited) < len(graph):
-        minDistance = -1
-        minKey = ''
+        min_distance = -1
+        min_key = ''
         for key in graph:
             distance = math.inf if key not in distances else distances[key]
-            if key not in visited and (minDistance == -1 or distance < minDistance):
-                minDistance = distance
-                minKey = key
-        visited[minKey] = 1
+            if key not in visited and (min_distance == -1 or distance < min_distance):
+                min_distance = distance
+                min_key = key
+        visited[min_key] = 1
 
-        for vertex in graph[minKey]:
-            if vertex not in distances or minDistance + 1 < distances[vertex]:
-                distances[vertex] = minDistance + 1
+        for vertex in graph[min_key]:
+            if vertex not in distances or min_distance + 1 < distances[vertex]:
+                distances[vertex] = min_distance + 1
 
     return distances[destination]
 
-print(f'Part one: {partOne()}')
-print(f'Part two: {partTwo()}')
+
+print(f'Part one: {part_one()}')
+print(f'Part two: {part_two()}')

2019/07/07.py

@@ -5,17 +5,18 @@
 line = inputFile.read().rstrip()
 inputFile.close()
 
-def partOne():
-    def getOutput(input1, input2):
+
+def part_one():
+    def get_output(input1, input2):
         program = [int(i) for i in line.split(',')]
-        output = i = inputNum = 0
+        output = i = input_num = 0
         while i < len(program):
             instruction = str(program[i]).zfill(5)
             if instruction[-1] == '9':
                 return output
             elif instruction[-1] == '3':
-                program[program[i + 1]] = input1 if inputNum == 0 else input2
-                inputNum += 1
+                program[program[i + 1]] = input1 if input_num == 0 else input2
+                input_num += 1
                 i += 2
             elif instruction[-1] == '4':
                 output = program[program[i + 1]]
@@ -44,11 +45,12 @@ def getOutput(input1, input2):
     for sequence in list(itertools.permutations([0, 1, 2, 3, 4])):
         output = 0
         for phase in sequence:
-            output = getOutput(phase, output)
+            output = get_output(phase, output)
         res = max(res, output)
     return res
 
-def partTwo():
+
+def part_two():
     res = 0
     for feedbackSequence in list(itertools.permutations([5, 6, 7, 8, 9])):
         inputs = [[phase] for phase in feedbackSequence]
@@ -92,5 +94,6 @@ def partTwo():
         res = max(res, inputs[0][-1])
     return res
 
-print(f'Part one: {partOne()}')
-print(f'Part two: {partTwo()}')
+
+print(f'Part one: {part_one()}')
+print(f'Part two: {part_two()}')

2019/08/08.py

@@ -4,30 +4,33 @@
 image = inputFile.read().rstrip()
 inputFile.close()
 
-def partOne():
+
+def part_one():
     i = zeros = ones = twos = res = 0
-    fewest = layerSize = 25 * 6
+    fewest = layer_size = 25 * 6
     for pixel in image:
         i += 1
         zeros += pixel == '0'
         ones += pixel == '1'
         twos += pixel == '2'
-        if i % layerSize == 0:
+        if i % layer_size == 0:
             if zeros < fewest:
                 fewest = zeros
                 res = ones * twos
             zeros = ones = twos = 0
     return res
 
-def partTwo():
-    layerSize = 25 * 6
+
+def part_two():
+    layer_size = 25 * 6
     output = ''
-    for i in range(layerSize):
+    for i in range(layer_size):
         j = i
         while image[j] == '2':
-            j += layerSize
+            j += layer_size
         output += image[j] if len(output) % 26 else f'\n{image[j]}'
     return output
-        
-print(f'Part one: {partOne()}')
-print(f'Part two: {partTwo()}')
+
+
+print(f'Part one: {part_one()}')
+print(f'Part two: {part_two()}')

2019/09/09.py

@@ -4,6 +4,7 @@
 line = inputFile.read().rstrip()
 inputFile.close()
 
+
 def run(input1):
     program = dict(enumerate(int(i) for i in line.split(',')))
     output = i = base = 0
@@ -54,5 +55,6 @@ def run(input1):
             base += program[key1]
             i += 2
 
+
 print(f'Part one: {run(1)}')
 print(f'Part two: {run(2)}')

2019/10/10.py

@@ -5,8 +5,9 @@
 lines = [line.rstrip('\n') for line in inputFile]
 inputFile.close()
 
+
 def solve():
-    def getScore(row, col):
+    def get_score(row, col):
         gradients = {}
         for i in range(len(lines)):
             for j in range(len(lines[0])):
@@ -30,44 +31,44 @@ def getScore(row, col):
                         gradients[(quadrant, gradient)] = [(i, j)]
         return gradients
 
-    partOne = bestRow = bestCol = 0
-    bestGradients = {}
+    part_one = best_row = best_col = 0
+    best_gradients = {}
     for row in range(len(lines)):
         for col in range(len(lines[0])):
             if lines[row][col] == '#':
-                gradients = getScore(row, col)
-                if len(gradients) > partOne:
-                    partOne = len(gradients) # Number of unique gradients
-                    bestRow = row
-                    bestCol = col
-                    bestGradients = gradients
-    
+                gradients = get_score(row, col)
+                if len(gradients) > part_one:
+                    part_one = len(gradients)  # Number of unique gradients
+                    best_row = row
+                    best_col = col
+                    best_gradients = gradients
+
     # Sort values for each gradient by manhattan distance
-    for key in bestGradients:
-        bestGradients[key].sort(key=lambda x: abs(bestRow - x[0]) + abs(bestCol - x[1]))
+    for key in best_gradients:
+        best_gradients[key].sort(key=lambda x: abs(best_row - x[0]) + abs(best_col - x[1]))
 
     # Separate gradients into 4 quadrants going clockwise starting from top right
     quadrants = [[], [], [], []]
-    for quadrant, gradient in bestGradients:
+    for quadrant, gradient in best_gradients:
         quadrants[quadrant].append(gradient)
 
     # Sort gradients in each quadrant
     for quadrant in range(4):
         quadrants[quadrant].sort(reverse=True)
 
-    partTwo = count = 0
+    count = 0
     while 1:
         for quadrant in range(4):
             for gradient in quadrants[quadrant]:
-                points = bestGradients[(quadrant, gradient)]
+                points = best_gradients[(quadrant, gradient)]
                 if len(points):
-                    partTwo = points[0]
-                    points = points[1:]
+                    part_two = points[0]
                     count += 1
 
                     if count == 200:
-                        print(f'Part one: {partOne}')
-                        print(f'Part two: {partTwo[1] * 100 + partTwo[0]}')
-                        return 
+                        print(f'Part one: {part_one}')
+                        print(f'Part two: {part_two[1] * 100 + part_two[0]}')
+                        return
+
 
 solve()