Various improvements

Author: Piratmac

2020/02-Password Philosophy.py

@@ -39,31 +39,20 @@ def words(s: str):
     "expected": ["2", "1"],
 }
 
-test = "WD"
+test = "real"
 input_file = os.path.join(
     os.path.dirname(__file__),
     "Inputs",
-    os.path.basename(__file__).replace(".py", ".WD.txt"),
+    os.path.basename(__file__).replace(".py", ".txt"),
 )
 test_data[test] = {
     "input": open(input_file, "r+").read(),
-    "expected": ["Unknown", "Unknown"],
-}
-
-test = "Twitter"
-input_file = os.path.join(
-    os.path.dirname(__file__),
-    "Inputs",
-    os.path.basename(__file__).replace(".py", ".Twitter.txt"),
-)
-test_data[test] = {
-    "input": open(input_file, "r+").read(),
-    "expected": ["447", "Unknown"],
+    "expected": ["447", "249"],
 }
 
 # -------------------------------- Control program execution ------------------------- #
 
-case_to_test = "Twitter"
+case_to_test = "real"
 part_to_test = 2
 
 # -------------------------------- Initialize some variables ------------------------- #

2020/04-Passport Processing.py

@@ -106,68 +106,52 @@ def words(s: str):
 
 # -------------------------------- Actual code execution ----------------------------- #
 
-required_fields = ["byr", "iyr", "eyr", "hgt", "hcl", "ecl", "pid"]
+
+class Passport:
+    required_fields = ["byr", "iyr", "eyr", "hgt", "hcl", "ecl", "pid"]
+
+    validations = {
+        "byr": lambda year: year in range(1920, 2002 + 1),
+        "iyr": lambda year: year in range(2010, 2020 + 1),
+        "eyr": lambda year: year in range(2020, 2030 + 1),
+        "hgt": lambda data: (
+            data[-2:] == "cm" and int(data[:-2]) in range(150, 193 + 1)
+        )
+        or (data[-2:] == "in" and int(data[:-2]) in range(59, 76 + 1)),
+        "hcl": lambda data: re.match("^#[0-9a-f]{6}$", data),
+        "ecl": lambda data: data in ["amb", "blu", "brn", "gry", "grn", "hzl", "oth"],
+        "pid": lambda data: re.match("^[0-9]{9}$", data),
+    }
+
+    def __init__(self, data):
+        self.fields = defaultdict(str)
+        for element in data.split():
+            if element[:3] in ("byr", "iyr", "eyr"):
+                try:
+                    self.fields[element[:3]] = int(element[4:])
+                except:
+                    self.fields[element[:3]] = element[4:]
+            else:
+                self.fields[element[:3]] = element[4:]
+
+    def has_required_data(self):
+        return all([x in self.fields for x in self.required_fields])
+
+    def is_valid(self):
+        return all([self.validations[x](self.fields[x]) for x in self.required_fields])
+
 
 passports = []
-i = 0
-for string in puzzle_input.split("\n"):
-    if len(passports) >= i:
-        passports.append("")
-    if string == "":
-        i = i + 1
-    else:
-        passports[i] = passports[i] + " " + string
+for string in puzzle_input.split("\n\n"):
+    passports.append(Passport(string))
 
 valid_passports = 0
 
 if part_to_test == 1:
-    for passport in passports:
-        if all([x + ":" in passport for x in required_fields]):
-            valid_passports = valid_passports + 1
-
+    valid_passports = sum([1 for x in passports if x.has_required_data()])
 
 else:
-    for passport in passports:
-        if all([x + ":" in passport for x in required_fields]):
-            fields = passport.split(" ")
-            score = 0
-            for field in fields:
-                data = field.split(":")
-                if data[0] == "byr":
-                    year = int(data[1])
-                    if year >= 1920 and year <= 2002:
-                        score = score + 1
-                elif data[0] == "iyr":
-                    year = int(data[1])
-                    if year >= 2010 and year <= 2020:
-                        score = score + 1
-                elif data[0] == "eyr":
-                    year = int(data[1])
-                    if year >= 2020 and year <= 2030:
-                        score = score + 1
-                elif data[0] == "hgt":
-                    size = ints(data[1])[0]
-                    if data[1][-2:] == "cm":
-                        if size >= 150 and size <= 193:
-                            score = score + 1
-                    elif data[1][-2:] == "in":
-                        if size >= 59 and size <= 76:
-                            score = score + 1
-                elif data[0] == "hcl":
-                    if re.match("#[0-9a-f]{6}", data[1]) and len(data[1]) == 7:
-                        score = score + 1
-                        print(data[0], passport)
-                elif data[0] == "ecl":
-                    if data[1] in ["amb", "blu", "brn", "gry", "grn", "hzl", "oth"]:
-                        score = score + 1
-                        print(data[0], passport)
-                elif data[0] == "pid":
-                    if re.match("[0-9]{9}", data[1]) and len(data[1]) == 9:
-                        score = score + 1
-                        print(data[0], passport)
-            print(passport, score)
-            if score == 7:
-                valid_passports = valid_passports + 1
+    valid_passports = sum([1 for x in passports if x.is_valid()])
 
 puzzle_actual_result = valid_passports
 

2020/07-Handy Haversacks.py

@@ -145,7 +145,7 @@ def words(s: str):
                 gold_contains["total"] += gold_contains[combination["out"]]
                 del gold_contains[combination["out"]]
 
-        print(sum(gold_contains.values()), gold_contains)
+    #        print(sum(gold_contains.values()), gold_contains)
 
     puzzle_actual_result = gold_contains["total"]
 

2020/08-Handheld Halting.py

@@ -92,7 +92,7 @@ def run(self):
 
     def run_once(self):
         instr = self.instructions[self.current_line]
-        print("Before", self.current_line, self.accumulator, instr)
+        # print("Before", self.current_line, self.accumulator, instr)
         self.operations[instr[0]](instr)
 
     def nop(self, instr):

2020/09-Encoding Error.py

@@ -109,7 +109,7 @@ def words(s: str):
         if number_sum < invalid_number:
             for b in range(1, len(numbers) - a):
                 number_sum += numbers[a + b]
-                print(a, b, number_sum, invalid_number)
+                #                print(a, b, number_sum, invalid_number)
                 if number_sum == invalid_number:
                     puzzle_actual_result = min(numbers[a : a + b + 1]) + max(
                         numbers[a : a + b + 1]

2020/10-Adapter Array.py

@@ -93,7 +93,7 @@ def words(s: str):
 )
 test_data[test] = {
     "input": open(input_file, "r+").read(),
-    "expected": ["Unknown", "Unknown"],
+    "expected": ["2240", "99214346656768"],
 }
 
 
@@ -142,7 +142,7 @@ def words(s: str):
     for joltage in joltages:
         edges[joltage] = [x for x in joltages if x < joltage and x >= joltage - 3]
 
-    print(edges)
+    #    print(edges)
 
     @lru_cache(maxsize=len(joltages))
     def count_paths(position):
@@ -162,3 +162,5 @@ def count_paths(position):
 print("Expected result : " + str(puzzle_expected_result))
 print("Actual result   : " + str(puzzle_actual_result))
 # Date created: 2020-12-10 06:00:02.437611
+# Part 1: 2020-12-10 06:04:42
+# Part 2: 2020-12-10 06:14:12

2020/grid.py

@@ -86,7 +86,7 @@ def text_to_dots(self, text, ignore_terrain=""):
         The dots will have x - y * 1j as coordinates
 
         :param string text: The text to convert
-        :param sequence ignore_terrain: The grid to convert
+        :param sequence ignore_terrain: Types of terrain to ignore (useful for walls)
         """
         self.dots = {}