def countLinesWithoutDuplicates(fileName): count = 0 for line in base.getInputLines(fileName): splitLine = line.split(' ') if len(splitLine) == len(set(splitLine)): count += 1 return count
def countLinesWithoutAnagrams(fileName): count = 0 for line in base.getInputLines(fileName): sortedWords = [''.join(sorted(w)) for w in line.split(' ')] if len(sortedWords) == len(set(sortedWords)): count += 1 return count
def lifeSupportRating(fileName): readings = list(base.getInputLines(fileName)) oxygenGeneratorRating, co2ScrubberRating = splitLists(readings) o2rating = int(oxygenGeneratorRating, 2) co2rating = int(co2ScrubberRating, 2) return "O2: {} ({}), CO2: {} ({}), Rating: {}".format( oxygenGeneratorRating, o2rating, co2ScrubberRating, co2rating, o2rating * co2rating)
def readLines(fileName, ignoreDiagonals=False): pattern = re.compile(r"(\d+),(\d+) -> (\d+),(\d+)") for line in base.getInputLines(fileName): match = pattern.match(line) if match: x1, y1, x2, y2 = match.groups() if not ignoreDiagonals or x1 == x2 or y1 == y2: yield lines.Line((x1, y1), (x2, y2))
def readMyFlips(self, fileName): """ No new taxes. :return: """ for line in base.getInputLines(fileName): self.flip(line)
def readDirections(self, fileName): move = None for pair in base.getInputLines(fileName, delimiter=', '): direction = pair[0] value = int(pair[1:]) logger.debug("{}: Pos: {}: Heading:{}".format( pair, self.pos, self.heading)) func = self.transformationFuncs[direction] self._move(*func(direction, value))
def parseFile(fileName): total = 0 length = 0 sp = stringprocessor.StringDecoder() for line in base.getInputLines(fileName): processed = sp.processLine(line) print("Original: <{}>. Current <{}>. Diff: {} - {} = {}".format( line, processed, len(line), len(processed), len(line) - len(processed))) total += len(line) - len(processed) return total
def readReindeer(self, fileName): deers = [] pattern = re.compile( "(\w+) can fly (\d+) km/s for (\d+) seconds, but then must rest for (\d+) seconds." ) for line in base.getInputLines(fileName): match = pattern.match(line) deers.append( Reindeer(match.group(1), int(match.group(2)), int(match.group(3)), int(match.group(4)))) return deers
def readInput(self, fileName): masksCurrent = None for line in base.getInputLines(fileName): if (line): prefix, suffix = line.split(' = ') if prefix == "mask": masksCurrent = self.createMasks(suffix) else: self.write(int(prefix.strip('me[] ')), suffix, masksCurrent)
def readIDs(fileName): firstIgnored = False ids = [] offset = 0 for stamp in base.getInputLines(fileName, delimiter=','): if not firstIgnored: firstIgnored = True elif stamp == 'x': offset += 1 else: ids.append((int(stamp), offset)) offset += 1 return ids
def readInput(self, fileName): self.state = ST_INITIAL for line in base.getInputLines(fileName): # print("{}: {}".format(self.state, line)) if not line: pass elif line[:12] == "your ticket:": msg = '\n'.join([ "{}: {}".format(rule.name, rule.ranges) for rule in self.rules ]) logger.debug( "{}.{}: STATE CHANGE => ST_YOUR_TICKET: {} rules:\n{}". format(self.__class__.__name__, inspect.currentframe().f_code.co_name, len(self.rules), msg)) self.state = ST_YOUR_TICKET elif line == "nearby tickets:": logger.debug( "{}.{}: STATE CHANGE => ST_NEARBY_TICKETS: My ticket: {}". format(self.__class__.__name__, inspect.currentframe().f_code.co_name, self.myTicket)) self.state = ST_NEARBY_TICKETS elif self.state == ST_INITIAL: match = re.match(r"(.+): (\d+)-(\d+) or (\d+)-(\d+)", line) if match: # print(match.groups()) self.rules.append( TicketRule(*match.groups()[1:], name=match.groups()[0])) elif self.state == ST_YOUR_TICKET: if self.myTicket: logger.warning("{}.{}: Duplicated my ticket?".format( self.__class__.__name__, inspect.currentframe().f_code.co_name)) self.myTicket = [int(num) for num in line.split(',')] elif self.state == ST_NEARBY_TICKETS: ticket = [int(num) for num in line.split(',')] ticketValid = True for val in ticket: if not self._isValid(val): self.invalidValueSum += val ticketValid = False if ticketValid: self.tickets.append(ticket) logger.debug("{}.{}: Valid tickets:\n{}".format( self.__class__.__name__, inspect.currentframe().f_code.co_name, '\n'.join([str(ticket) for ticket in self.tickets])))
def readHands(fileName): hand = [] for line in base.getInputLines(fileName): # print(line) if not line: pass elif line[:6] == "Player": if hand: yield hand[::-1] hand.clear() else: # print(line) hand.append(int(line)) yield hand[::-1]
def readVectors(fileName): for instruction in base.getInputLines(fileName): direction, distance = instruction.split() unitVectors = {"forward": (1, 0), "up": (0, -1), "down": (0, 1), } vector = tuple([x * int(distance) for x in unitVectors[direction]]) logging.debug("{}(\"{}\"): direction: \"{}\", distance: {}, vector: {}".format(sys._getframe().f_code.co_name, instruction, direction, distance, vector)) yield vector
def totalRepeats(fileName): firstDigit = None total = 0 for line in base.getInputLines(fileName): for char in line: currentDigit = int(char) if not firstDigit: firstDigit = currentDigit elif currentDigit == prevDigit: total += currentDigit prevDigit = currentDigit if prevDigit == firstDigit: total += firstDigit return total
def _populateCubes(self, fileName): logger.debug("Starting: {}.{}: file: {}".format( self.__class__.__name__, inspect.currentframe().f_code.co_name, fileName)) rowID = 0 for row in base.getInputLines(fileName): for colID in range(len(row)): if row[colID] == "#": self.activeCubes.append(self.cubeClass( (rowID, colID))) # Cube auto-pads out additional dimensions rowID += 1 logger.debug("Ending: {}.{}: # of cubes: {}".format( self.__class__.__name__, inspect.currentframe().f_code.co_name, len(self.activeCubes)))
class TestStringEncoder(unittest.TestCase): fsTest = ["test2015_08a.txt", "test2015_08b.txt"] sd = stringprocessor.StringDecoder() se = stringprocessor.StringEncoder() lines = [ line for fileName in fsTest for line in base.getInputLines(fileName) ] expecteds = [0, 3, 7, 1, 2, 2, 6] def test_processLine_allFromFile(self): for i in range(len(self.lines)): processed = self.sd.processLine(self.lines[i]) msg = "{}: {}: <{}>, <{}>".format(i, self.expecteds[i], self.lines[i], processed) self.assertEqual(self.expecteds[i], len(processed), msg)
def _populateSeats(self, fileName, immediateAdjacency, threshold): logger.debug("Starting: {}.{}: file: {}".format(self.__class__.__name__, inspect.currentframe().f_code.co_name, fileName)) rowID = 0 for row in base.getInputLines(fileName): for colID in range(len(row)): if row[colID] == "L" or row[colID] == "#": self._addSeatToCollective(Seat(row[colID], (rowID, colID), threshold), immediateAdjacency) self.seatingPlan.append(list(row)) # print(row) rowID += 1 self.dims = (len(self.seatingPlan), len(self.seatingPlan[0])) logger.debug("Ending: {}.{}: Dimensions: {}. # of seats: {}".format( self.__class__.__name__, inspect.currentframe().f_code.co_name, self.dims, len(self.seatsUnresolved)))
def nextBus(fileName): shortestWait = float('inf') idNearest = None timestamp = None for stamp in base.getInputLines(fileName, delimiter=','): if stamp == 'x': pass elif timestamp: delay = timestamp % int(stamp) if delay < shortestWait: shortestWait = delay idNearest = int(stamp) else: timestamp = -int(stamp) return (shortestWait * idNearest, shortestWait, idNearest)
def readVectorsV2(fileName): aim = [1, 0] for instruction in base.getInputLines(fileName): direction, distString = instruction.split() distance = int(distString) if direction == "down": aim[1] += distance elif direction == "up": aim[1] -= distance elif direction == "forward": moveVector = tuple([x * distance for x in aim]) yield moveVector else: logging.warning("{}(\"{}\"): Unrecognised direction: \"{}\"".format(sys._getframe().f_code.co_name, fileName, direction))
def _readTiles(fileName): tileBuffer = [] for line in base.getInputLines(fileName): # print(line) if not line: pass elif line[:4] == "Tile" and tileBuffer: yield Tile(tileBuffer) tileBuffer.clear() tileBuffer.append(line.strip()) else: tileBuffer.append(line.strip()) yield Tile(tileBuffer)
def __init__(self, fileName): self.cards = [] self.sequence = [] currentCard = [] for line in base.getInputLines(fileName): if ',' in line: self.sequence.extend(line.split(',')) elif not line: if currentCard: self.addCard(currentCard) currentCard = [] else: currentCard.append(line.split()) if currentCard: self.addCard(currentCard)
def _parseFile(self, fileName): """ Read section one of the file into a RuleTree and section two into a list of tokens to be validated :param fileName: :return: """ for definition in base.getInputLines(fileName): if ':' in definition: node = RuleSet(definition) if not node: pass elif node.terminals: self.nodesEvaluated[node.id] = node.terminals else: self.nodesUnevaluated[node.id] = node self._addToWaitingLists(node.id, node.nonTerminals) elif definition: self.tokensUnvalidated.append(definition)
class TestStringDecoder(unittest.TestCase): fsTest = ["test2015_08a.txt", "test2015_08b.txt"] lines = [ line for fileName in fsTest for line in base.getInputLines(fileName) ] expecteds = [0, 3, 7, 1, 2, 2, 6] # ['""', '"abc"', '"aaa\\"aaa"', '"\\x27"', '"\\\\\\xf3"', '"\\\\\\""', '"b\\\\\\\\xda"'] # [r'""', r'"abc"', r'"aaa\"aaa"', r'"\x27"', r'"\\\xf3"', r'"\\\""', r'"b\\\\xda"'] # print(lines) sd = stringprocessor.StringDecoder() def test_processLine_abc_fromFile(self): processed = self.sd.processLine(self.lines[1]) self.assertEqual(3, len(processed)) def test_processLine_abc_fromString(self): processed = self.sd.processLine('\"abc\"') self.assertEqual(3, len(processed)) def test_processLine_abc_fromString2(self): processed = self.sd.processLine('"abc"') self.assertEqual(3, len(processed)) def test_processLine_empty_fromFile(self): processed = self.sd.processLine(self.lines[0]) self.assertEqual(0, len(processed)) def test_processLine_empty_fromString(self): processed = self.sd.processLine('\"\"') self.assertEqual(0, len(processed)) def test_processLine_empty_fromString2(self): processed = self.sd.processLine('""') self.assertEqual(0, len(processed)) def test_processLine_allFromFile(self): for i in range(len(self.lines)): processed = self.sd.processLine(self.lines[i]) msg = "{}: {}: <{}>, <{}>".format(i, self.expecteds[i], self.lines[i], processed) self.assertEqual(self.expecteds[i], len(processed), msg)
def countDigits(fileName): """ Count the digits in each position of a set of numbers. Do not assume same lengths or exclusive membership of a digit set. :param fileName: Input file :return: (total count of numbers, [counts of each digit]) """ counts = [] for digits in base.getInputLines(fileName): # print("\"{}\", len:{}".format(digits, len(digits))) shortfall = len(digits) - len(counts) counts.extend([dict() for i in range(shortfall)]) for i in range(len(digits)): if digits[i] in counts[i]: counts[i][digits[i]] += 1 else: counts[i][digits[i]] = 1 return counts
def readFile(self, fileName): for line in base.getInputLines(fileName): ingredients, allergens = self._processLine(line) # print("ingredients: {}, allergens: {}".format(ingredients, allergens)) for allergen in allergens: unAllocatedIngredients = [i for i in ingredients if i not in self.ingredientsResolved] if allergen not in self.allergenCandidates: self.allergenCandidates[allergen] = set(unAllocatedIngredients) else: self.allergenCandidates[allergen] &= set(unAllocatedIngredients) if len(self.allergenCandidates[allergen]) == 1: candidate = self.allergenCandidates[allergen].pop() self.ingredientsResolved[candidate] = allergen for ingredient in ingredients: if ingredient in self.ingredientCounts: self.ingredientCounts[ingredient] += 1 else: self.ingredientCounts[ingredient] = 1 resolved = True while resolved: resolved = False toBeDeleted = [] for allergen, candidates in self.allergenCandidates.items(): if len(candidates) > 0: candidates -= set([k for k in self.ingredientsResolved.keys()]) if len(candidates) == 1: candidate = self.allergenCandidates[allergen].pop() self.ingredientsResolved[candidate] = allergen resolved = True if not len(candidates): toBeDeleted.append(allergen) for candidate in toBeDeleted: del self.allergenCandidates[candidate] self.part1 = sum([val for k, val in self.ingredientCounts.items() if k not in self.ingredientsResolved]) sortedByValue = sorted(self.ingredientsResolved.items(), key=lambda kv: kv[1]) self.part2 = ','.join([k for k, v in sortedByValue])
def _populateTree(self, fileName): BooleanOpTree.evaluatedOutputs.clear() nodes = [] for definition in base.getInputLines(fileName): node = self._turnDefinitionIntoTreeNode(definition) if node and node.unresolvedInputs: nodes.append(node) nodeCount = len(nodes) + 1 while nodeCount > len(nodes): nodeCount = len(nodes) print("Starting loop: {} nodes.".format(nodeCount)) activeNodes = nodes[:] nodes = [] for node in activeNodes: node.evaluate() if node.unresolvedInputs: nodes.append(node) self.evaluatedOutputs = {k: v for k, v in BooleanOpTree.evaluatedOutputs.items()} print("evaluatedOutputs: ", sorted(BooleanOpTree.evaluatedOutputs))
def readRepetitions(self, fileName): for line in base.getInputLines(fileName): self.repetitions.append(line.strip())
def readStream(self, fileName): for line in base.getInputLines(fileName): for char in line: self.inject(char)
def checksumFromFile(fileName): total = 0 for row in base.getInputLines(fileName): entries = [int(e) for e in row.split('\t')] total += max(entries) - min(entries) return total
def factorsFromFile(fileName): total = 0 for row in base.getInputLines(fileName): entries = sorted([int(e) for e in row.split('\t')]) total += findIntegerDivision(entries) return total