Added days 2018-03, 2018-04

Piratmac · Piratmac · commit 6d33d35f439f · 2020-06-07T19:16:43.000+02:00
diff --git a/2018/03-No Matter How You Slice It.py b/2018/03-No Matter How You Slice It.py
@@ -0,0 +1,87 @@
+# -------------------------------- Input data -------------------------------- #
+import os, drawing
+
+test_data = {}
+
+test = 1
+test_data[test]   = {"input": """#1 @ 1,3: 4x4
+#2 @ 3,1: 4x4
+#3 @ 5,5: 2x2""",
+                     "expected": ['Unknown', 'Unknown'],
+                    }
+
+test = 'real'
+input_file = os.path.join(os.path.dirname(__file__), 'Inputs', os.path.basename(__file__).replace('.py', '.txt'))
+test_data[test] = {"input": open(input_file, "r+").read().strip(),
+                     "expected": ['110546', '819'],
+                    }
+
+# -------------------------------- Control program execution -------------------------------- #
+
+case_to_test  = 'real'
+part_to_test  = 2
+verbose_level = 1
+
+# -------------------------------- Initialize some variables -------------------------------- #
+
+puzzle_input           = test_data[case_to_test]['input']
+puzzle_expected_result = test_data[case_to_test]['expected'][part_to_test-1]
+puzzle_actual_result   = 'Unknown'
+
+
+# -------------------------------- Actual code execution -------------------------------- #
+
+if part_to_test == 1:
+    fabric = {}
+    for string in puzzle_input.split('\n'):
+        if string == '':
+            continue
+        _, _, start, size = string.split(' ')
+        cut_x, cut_y = int(start.split(',')[0]), int(start.split(',')[1][:-1])
+        size_x, size_y = int(size.split('x')[0]), int(size.split('x')[1])
+
+        fabric.update({(x, y): fabric.get((x, y), 0) + 1
+                        for x in range (cut_x, cut_x + size_x)
+                        for y in range (cut_y, cut_y + size_y)})
+
+    puzzle_actual_result = len([fabric[coord] for coord in fabric if fabric[coord] > 1])
+
+
+
+else:
+    fabric = {}
+    cuts = []
+    for string in puzzle_input.split('\n'):
+        if string == '':
+            continue
+        _, _, start, size = string.split(' ')
+        cut_x, cut_y = int(start.split(',')[0]), int(start.split(',')[1][:-1])
+        size_x, size_y = int(size.split('x')[0]), int(size.split('x')[1])
+
+        cuts.append((cut_x, cut_y, size_x, size_y))
+
+        fabric.update({(x, y): fabric[(x, y)] + 1 if (x, y) in fabric else 1
+                        for x in range (cut_x, cut_x + size_x)
+                        for y in range (cut_y, cut_y + size_y)})
+
+    cut_id = 0
+    for cut in cuts:
+        cut_id += 1
+        if all(fabric[(x, y)] == 1
+                for x in range (cut[0], cut[0] + cut[2])
+                for y in range (cut[1], cut[1] + cut[3])):
+            puzzle_actual_result = cut_id
+            break
+
+
+
+# -------------------------------- Outputs / results -------------------------------- #
+
+if verbose_level >= 3:
+    print ('Input : ' + puzzle_input)
+print ('Expected result : ' + str(puzzle_expected_result))
+print ('Actual result   : '   + str(puzzle_actual_result))
+
+
+
+
diff --git a/2018/04-Repose Record.py b/2018/04-Repose Record.py
@@ -0,0 +1,105 @@
+# -------------------------------- Input data -------------------------------- #
+import os, parse, numpy as np
+
+test_data = {}
+
+test = 1
+test_data[test]   = {"input": """[1518-11-01 00:00] Guard #10 begins shift
+[1518-11-01 00:05] falls asleep
+[1518-11-01 00:25] wakes up
+[1518-11-01 00:30] falls asleep
+[1518-11-01 00:55] wakes up
+[1518-11-01 23:58] Guard #99 begins shift
+[1518-11-02 00:40] falls asleep
+[1518-11-02 00:50] wakes up
+[1518-11-03 00:05] Guard #10 begins shift
+[1518-11-03 00:24] falls asleep
+[1518-11-03 00:29] wakes up
+[1518-11-04 00:02] Guard #99 begins shift
+[1518-11-04 00:36] falls asleep
+[1518-11-04 00:46] wakes up
+[1518-11-05 00:03] Guard #99 begins shift
+[1518-11-05 00:45] falls asleep
+[1518-11-05 00:55] wakes up""",
+                     "expected": ['240', 'Unknown'],
+                    }
+
+test = 'real'
+input_file = os.path.join(os.path.dirname(__file__), 'Inputs', os.path.basename(__file__).replace('.py', '.txt'))
+test_data[test] = {"input": open(input_file, "r+").read().strip(),
+                     "expected": ['30630', '136571'],
+                    }
+
+# -------------------------------- Control program execution -------------------------------- #
+
+case_to_test  = 1
+part_to_test  = 1
+verbose_level = 1
+
+# -------------------------------- Initialize some variables -------------------------------- #
+
+puzzle_input           = test_data[case_to_test]['input']
+puzzle_expected_result = test_data[case_to_test]['expected'][part_to_test-1]
+puzzle_actual_result   = 'Unknown'
+
+
+# -------------------------------- Actual code execution -------------------------------- #
+
+parse_format1 = '''[{date:ti}] Guard #{guard:d} begins shift'''
+parse_format2 = '''[{date:ti}] falls asleep'''
+parse_format3 = '''[{date:ti}] wakes up'''
+all_notes = sorted(puzzle_input.split('\n'))
+
+sleep_pattern = {}
+for string in all_notes:
+    r = parse.parse(parse_format1, string)
+    if r is not None:
+        guard = r['guard']
+        if guard not in sleep_pattern:
+            sleep_pattern[guard] = np.zeros(60)
+        continue
+
+    r = parse.parse(parse_format2, string)
+    if r is not None:
+        asleep = r['date'].minute if r['date'].hour == 0 else 0
+        continue
+
+    r = parse.parse(parse_format3, string)
+    if r is not None:
+        sleep_pattern[guard][asleep:r['date'].minute] += 1
+        continue
+
+if part_to_test == 1:
+    sleep_duration = {x:sum(sleep_pattern[x]) for x in sleep_pattern}
+
+    most_sleepy = [x for x,v in sleep_duration.items() if v == max(sleep_duration.values())][0]
+
+    puzzle_actual_result = most_sleepy * np.argpartition(-sleep_pattern[most_sleepy], 1)[0]
+
+
+else:
+    most_slept = 0
+    most_slept_guard = 0
+    most_slept_minute = 0
+    for guard in sleep_pattern:
+        if most_slept < max(sleep_pattern[guard]):
+            most_slept = max(sleep_pattern[guard])
+            most_slept_guard = guard
+            most_slept_minute = np.argpartition(-sleep_pattern[guard], 1)[0]
+
+    puzzle_actual_result = most_slept_guard * most_slept_minute
+
+
+
+
+
+# -------------------------------- Outputs / results -------------------------------- #
+
+if verbose_level >= 3:
+    print ('Input : ' + puzzle_input)
+print ('Expected result : ' + str(puzzle_expected_result))
+print ('Actual result   : '   + str(puzzle_actual_result))
+
+
+
+
diff --git a/2018/drawing.py b/2018/drawing.py
@@ -0,0 +1,149 @@
+import math, os
+
+
+def text_to_grid (text):
+    """
+    Converts a text to a set of coordinates
+
+    The text is expected to be separated by newline characters
+    Each character will have its coordinates as keys
+
+    :param string text: The text to convert
+    :return: The converted grid, its height and width
+    """
+    grid = {}
+    lines = text.splitlines()
+    height = len(lines)
+    width = 0
+    for y in range(len(lines)):
+        width = max(width, len(lines[y]))
+        for x in range(len(lines[y])):
+            grid[(x, y)] = lines[y][x]
+
+    return grid
+
+def grid_to_text (grid, blank_character = ' '):
+    """
+    Converts the grid to a text format
+
+    :param dict grid: The grid to convert, in format (x, y): value
+    :param string blank_character: What to use for cells with unknown value
+    :return: The grid in text format
+    """
+
+    text = ''
+
+    grid_x, grid_y = zip(*grid.keys())
+
+    for y in range (min(grid_y), max(grid_y)+1):
+        for x in range (min(grid_x), max(grid_x)+1):
+            if (x, y) in grid:
+                text += str(grid[(x, y)])
+            else:
+                text += blank_character
+        text += os.linesep
+    text = text[:-len(os.linesep)]
+
+    return text
+
+def split_in_parts (grid, width, height):
+    """
+    Splits a grid in parts of width*height size
+
+    :param dict grid: The grid to convert, in format (x, y): value
+    :param integer width: The width of parts to use
+    :param integer height: The height of parts to use
+    :return: The different parts
+    """
+
+    if not isinstance(width, int) or not isinstance(height, int):
+        return False
+    if width <= 0 or height <= 0:
+        return False
+
+    grid_x, grid_y = zip(*grid.keys())
+    grid_width = max(grid_x) - min(grid_x) + 1
+    grid_height = max(grid_y) - min(grid_y) + 1
+
+    parts = []
+
+    for part_y in range(math.ceil(grid_height / height)):
+        for part_x in range (math.ceil(grid_width / width)):
+            parts.append({(x, y):grid[(x, y)] \
+                for x in range(part_x*width, min((part_x + 1)*width, grid_width)) \
+                for y in range(part_y*height, min((part_y + 1)*height, grid_height))})
+
+    return parts
+
+def merge_parts (parts, width, height):
+    """
+    Merges different parts in a single grid
+
+    :param dict parts: The parts to merge, in format (x, y): value
+    :return: The merged grid
+    """
+
+    grid = {}
+
+    part_x, part_y = zip(*parts[0].keys())
+    part_width = max(part_x) - min(part_x) + 1
+    part_height = max(part_y) - min(part_y) + 1
+
+    part_nr = 0
+    for part_y in range(height):
+        for part_x in range(width):
+            grid.update({(x + part_x*part_width, y + part_y*part_height): parts[part_nr][(x, y)] for (x, y) in parts[part_nr]})
+            part_nr += 1
+
+    return grid
+
+def rotate (grid, rotations = (0, 90, 180, 270)):
+    """
+    Rotates a grid and returns the result
+
+    :param dict grid: The grid to rotate, in format (x, y): value
+    :param tuple rotations: Which angles to use for rotation
+    :return: The parts in text format
+    """
+
+    rotated_grid = []
+
+    grid_x, grid_y = zip(*grid.keys())
+    width = max(grid_x) - min(grid_x) + 1
+    height = max(grid_y) - min(grid_y) + 1
+
+    for angle in rotations:
+        if angle == 0:
+            rotated_grid.append(grid)
+        elif angle == 90:
+            rotated_grid.append({(height-y, x): grid[(x, y)] for (x, y) in grid})
+        elif angle == 180:
+            rotated_grid.append({(width-x, height-y): grid[(x, y)] for (x, y) in grid})
+        elif angle == 270:
+            rotated_grid.append({(y, width-x): grid[(x, y)] for (x, y) in grid})
+
+    return rotated_grid
+
+def flip (grid, flips = ('V', 'H')):
+    """
+    Flips a grid and returns the result
+
+    :param dict grid: The grid to rotate, in format (x, y): value
+    :param tuple flips: Which flips (horizontal, vertical) to use for flip
+    :return: The parts in text format
+    """
+
+    flipped_grid = []
+
+    grid_x, grid_y = zip(*grid.keys())
+    width = max(grid_x) - min(grid_x) + 1
+    height = max(grid_y) - min(grid_y) + 1
+
+    for flip in flips:
+        if flip == 'H':
+            flipped_grid.append({(x, height-y): grid[(x, y)] for (x, y) in grid})
+        elif flip == 'V':
+            flipped_grid.append({(width-x, y): grid[(x, y)] for (x, y) in grid})
+
+    return flipped_grid
+
