Das deutsche Python-Forum

Code: Alles auswählen

#!/usr/bin/env python3
import fileinput
from itertools import cycle

def main():
    adjustments = [int(line) for line in fileinput.input()]
    print('Sum:', sum(adjustments))
    frequencies = set()
    frequency = 0
    for adjustment in cycle(adjustments):
        frequency += adjustment
        if frequency in frequencies:
            print("Repeat:", frequency)
            break
        frequencies.add(frequency)

if __name__ == '__main__':
    main()

Code: Alles auswählen

#!/usr/bin/awk -f
{
    sum += $1
    buffer[NR-1] = $1
}

END {
    print "Sum:", sum
    frequency = 0
    i = 0
    size = length(buffer)
    while (1) {
        frequency += buffer[i]
        if (frequency in seen) {
            print "Repeat:", frequency
            break
        }
        seen[frequency] = 1
        i = (i+1) % size
    }
}

Code: Alles auswählen

adjustments = [16, 9, 11, 13 ...
frequencies = set()
frequency = 0
not_seen = True

while not_seen:
    for adjustment in adjustments:
        frequency += adjustment
        if frequency in frequencies:
            print("Twice: ", frequency)
            not_seen = False
            break
        frequencies.add(frequency)

Code: Alles auswählen

frequencies = set()
frequency = 0

for adjustment in itertools.cycle(adjustments):
    frequency += adjustment
    if frequency in frequencies:
        print("Twice: ", frequency)
        break
    frequencies.add(frequency)

Code: Alles auswählen

from collections import Counter


def main():
    with open('item_ids.txt', 'r') as fd:
        box_ids = fd.read().splitlines()

    twice = 0
    triple = 0

    for box_id in box_ids:
        letter_count = Counter(box_id).values()
        if 2 in letter_count:
            twice += 1
        if 3 in letter_count:
            triple += 1

    print("Checksum: ", twice * triple)


if __name__ == '__main__':
    main()

Code: Alles auswählen

sequences = [...]

twos, threes = 0, 0
for sequence in sequences:
    count = {}
    for letter in sequence:
        try:
            count[letter] += 1
        except:
            count[letter] = 1
    most = set(count.values())
    if 2 in most:
        twos += 1
    if 3 in most:
        threes += 1

print(f'Checksum: {twos} * {threes} = {twos*threes}')

Code: Alles auswählen

from difflib import SequenceMatcher, ndiff

sequences = [...]
matcher = SequenceMatcher(None, '', '')
for row, first_sequence in enumerate(sequences):
    matcher.set_seq2(first_sequence)
    for column, second_sequence in enumerate(sequences):
        if column > row:
            matcher.set_seq1(second_sequence)
            if int(matcher.ratio() * len(first_sequence)) == len(first_sequence) - 1:
                matching = [letter[-1] for letter in ndiff(first_sequence, second_sequence) if letter[0] not in '+-']
                print(''.join(matching))

Code: Alles auswählen

from collections import Counter

two_seen = 0
three_seen = 0
with open('day02a.inp') as fobj:
    for line in fobj:
        n = {v for v in Counter(line).values()}
        two_seen = two_seen + 1 if 2 in n else two_seen
        three_seen = three_seen + 1 if 3 in n else three_seen
print(two_seen, three_seen)
print(two_seen * three_seen)

Code: Alles auswählen

def diff_by_one(p, q):
    return sum(1 for i, j in zip(p, q) if i != j) == 1

def check_against_known(known, new):
    for k in known:
        if diff_by_one(k, new):
            return k, new
    known.append(new)
    return None, None

def remove_uncommon(p, q):
    return ''.join(p for p, q in zip(p, q) if p==q)

with open('day02a.inp') as fobj:
    known = []
    for line in fobj:
        new = list(line.strip())
        p, q = check_against_known(known, new)
        if p:
            result = remove_uncommon(p, q)
            break
print(result)

Code: Alles auswählen

#!/usr/bin/env python3
import fileinput
from collections import Counter
from itertools import combinations

def get_difference(s1, s2):
    assert len(s1) == len(s2)
    return [i for i, chars in enumerate(zip(s1, s2)) if chars[0] != chars[1]]


def main():
    box_ids = [box_id.strip() for box_id in fileinput.input()]
    twos = 0
    threes = 0
    for box_id in box_ids:
        amounts = Counter(box_id)
        if 2 in amounts.values():
            twos += 1
        if 3 in amounts.values():
            threes += 1
    print('Result:', twos * threes)
    for pair in combinations(box_ids, 2):
        difference = get_difference(*pair)
        if len(difference) == 1:
            index = difference[0]
            print(pair[0][:index] + pair[0][index+1:])


if __name__ == '__main__':
    main()

Code: Alles auswählen

def make_frequency(changes):
    return sum(map(int, changes))

Code: Alles auswählen

from collections import Counter

two_seen = 0
three_seen = 0
with open('day02a.inp') as lines:
    for line in lines:
        n = set(Counter(line).values())
        two_seen += 2 in n
        three_seen += 3 in n
print(two_seen, three_seen)
print(two_seen * three_seen)

Code: Alles auswählen

import re
import numpy as np


PATTERN = re.compile(r'#(\d+) @ (\d+),(\d+): (\d+)x(\d+)')


def fabric_file(fobj):
    fobj.seek(0)
    for line in fobj:
        yield map(int, PATTERN.match(line).groups())

def get_dimensions(fobj):
    width = height = 0
    for _, x, y, w, h in fabric_file(fobj):
        width = max(width, x+w)
        height = max(height, y+h)
    return width, height

def get_fabric(fobj, width, height):
    fabric = np.zeros(width*height).reshape(width, height)
    for _, x, y, w, h in fabric_file(fobj):
        fabric[x:x+w, y:y+h] += 1
    return fabric

def get_nonoverlap_id(fobj, fabric):
    for i, x, y, w, h in fabric_file(fobj):
        if fabric[x:x+w, y:y+h].sum() == w * h:
            return i

with open('day03a.inp') as fobj:
    width, height = get_dimensions(fobj)
    fabric = get_fabric(fobj, width, height)
    print(len(fabric[fabric>1]))
    print(get_nonoverlap_id(fobj, fabric))

Code: Alles auswählen

from collections import deque

max_player = 452
last_marble = 71250 * 100 + 1

score = {key: 0 for key in range(1, max_player + 1)}
circle = deque([0])

current_player = 1
for marble in range(1, last_marble):
    if marble % 23 != 0:
        circle.rotate(-1)
        circle.append(marble)
    else:
        circle.rotate(8)
        score[current_player] += marble + circle[0]
        circle.popleft()
        circle.rotate(-1)
    current_player = current_player % max_player + 1

best_player = max(score, key=lambda key: score[key])
print(f'Best player {best_player} with Score {score[best_player]}')

Code: Alles auswählen

10 S=0:OPEN 2,8,2,"INPUT01,S"
20 INPUT#2,N:S=S+N:IF ST=0 THEN 20
30 CLOSE 2:PRINT S

Code: Alles auswählen

   10 TI$="000000":CR$=CHR$(13):A=ASC("A"):DIM ID(255,25),H(25)
  100 PRINT"READ IDS..."
  110 I=0:J=0:OPEN 2,8,2,"INPUT02,S"
  120 GET#2,C$:IF ST<>0 THEN 170
  130 PRINT C$;
  140 IF C$<>CR$ THEN ID(I,J)=ASC(C$)-A:J=J+1:GOTO 120
  150 PRINT"{UP}                                       "
  160 I=I+1:J=0:PRINT"{UP}";I;:GOTO 120
  170 CLOSE 2:IC=I:PRINT:PRINT TI$
  200 TI$="000000":PRINT:PRINT"PART 1...{DOWN}":C2=0:C3=0
  210 FOR I=0 TO IC:PRINT"{UP}";I
  220 FOR J=0 TO 25:H(J)=0:NEXT:FOR J=0 TO 25:K=ID(I,J):H(K)=H(K)+1:NEXT
  230 F2=0:F3=0:FOR J=0 TO 25:IF H(J)=2 THEN F2=-1
  240 IF H(J)=3 THEN F3=-1
  250 IF F2 AND F3 THEN J=25
  260 NEXT:C2=C2+-F2:C3=C3+-F3:NEXT:PRINT C2*C3:PRINT TI$
  300 TI$="000000":PRINT"PART 2...{DOWN}":FOR I=0 TO IC:PRINT"{UP}";I
  310 FOR J=I+1 TO IC:DC=0:DI=-1
  320 FOR K=0 TO 25:IF ID(I,K)<>ID(J,K) THEN DC=DC+1:DI=K:IF DC>1 THEN K=25
  330 NEXT:IF DC=1 THEN 400
  340 NEXT:NEXT:PRINT"NO SIMILAR IDS FOUND!":PRINT TI$:END
  400 FOR J=0 TO 25:IF J<>DI THEN PRINT CHR$(ID(I,J)+A);
  410 NEXT:PRINT:PRINT TI$

Code: Alles auswählen

#!/usr/bin/env python3
from attr import attrib, attrs


@attrs(frozen=True)
class Patch:
    id = attrib()
    x = attrib()
    y = attrib()
    width = attrib()
    height = attrib()

    @property
    def top(self):
        return self.y
    
    @property
    def bottom(self):
        return self.y + self.height
    
    @property
    def left(self):
        return self.x
    
    @property
    def right(self):
        return self.x + self.width

    def iter_coordinates(self):
        for y in range(self.top, self.bottom):
            for x in range(self.left, self.right):
                yield x, y

    @classmethod
    def from_line(cls, line):
        id_part, rect_part = line.split('@', 1)
        if not id_part.startswith('#'):
            raise ValueError('ID does not start with `#`')
        coordinate_part, dimension_part = rect_part.split(':', 1)
        x, y = map(int, coordinate_part.split(',', 1))
        width, height = map(int, dimension_part.split('x', 1))
        return cls(int(id_part[1:]), x, y, width, height)


class Sheet:
    
    def __init__(self, size=1000):
        self.squares = [[0] * size for _ in range(size)]

    @property
    def size(self):
        return len(self.squares)

    def get_max_value(self):
        return max(map(max, self.squares))
    
    def count_overlapped(self):
        return sum(sum(c > 1 for c in row) for row in self.squares)
    
    def check(self, patch):
        for x, y in patch.iter_coordinates():
            if self.squares[y][x] != 1:
                return False
        return True

    def claim(self, patch):
        for x, y in patch.iter_coordinates():
            self.squares[y][x] += 1
    
    def save_pgm(self, filename):
        max_value = self.get_max_value()
        if max_value > 255:
            raise ValueError('too many gray levels')
        with open(filename, 'wb') as out_file:
            out_file.write(
                f'P5 {self.size} {self.size} {self.get_max_value()}\n'.encode(
                    'ascii'
                )
            )
            out_file.writelines(map(bytes, self.squares))


def main():
    with open('input03.txt') as lines:
        patches = [Patch.from_line(line) for line in lines]
    print(
        'max width/height:',
        max(max(patch.width, patch.height) for patch in patches),
    )
    sheet = Sheet()
    for patch in patches:
        sheet.claim(patch)
    sheet.save_pgm('sheet.pgm')
    print(sheet.count_overlapped())
    print([patch for patch in patches if sheet.check(patch)])


if __name__ == '__main__':
    main()