Advent2023/5/advent_2.py

#!/usr/bin/env python3

from dataclasses import dataclass, field
import re


@dataclass
class Range:
    target: int
    source: int
    length: int
    endpoint: int = field(init=False)
    change: int = field(init=False)

    def __post_init__(self):
        self.endpoint = self.source + self.length
        self.change = self.target - self.source


@dataclass
class SR:
    startpoint: int
    length: int
    endpoint: int = field(init=False)

    def __post_init__(self):
        self.endpoint = self.startpoint + self.length


def getrangesource(range):
    return range.source


def findmapping(sr, tables, prefix):
    print(f"{prefix}Rekursiooni järel {len(tables)}")
    print(f"{prefix}{sr}")
    allresults = []
    if len(tables) == 0:
        print(f"{prefix}Tagasi, {sr.startpoint}")
        return sr.startpoint
    table = tables.pop(0)
    table.sort(key=getrangesource)
    print(f"{prefix}{table}")
    otsas = False
    for row in table:
        if sr.endpoint < row.source:
            # Väiksem kui käesolev mapping
            print(f"{prefix}P1")
            allresults.append(findmapping(sr, tables, prefix + "#"))
            otsas = True
            break
        if sr.startpoint < row.source:
            print(f"{prefix}P2")
            # vahemik algus on enne käesoleva mappingu algust, lõpp kuskil hiljem
            # kasutame ära vahemiku enne rea.source algust
            allresults.append(
                findmapping(
                    SR(sr.startpoint, row.source - sr.startpoint), tables, prefix + "#"
                )
            )
            if sr.endpoint > row.source:
                print(f"{prefix}P2 Vana {sr}")
                sr = SR(row.source, sr.endpoint - row.source)
                print(f"{prefix}P2 Uus {sr}")

        if sr.startpoint >= row.source:
            if sr.endpoint < row.endpoint:
                print(f"{prefix}P31")
                print(f"{prefix}Mapping {row} {sr} {len(tables)}")
                allresults.append(
                    findmapping(
                        SR(row.target + (sr.startpoint - row.source), sr.length),
                        tables,
                        prefix + "#",
                    )
                )
                otsas = True
                break
            if sr.endpoint >= row.endpoint and sr.startpoint < row.endpoint:
                print(f"{prefix}P32")
                print(f"{prefix}Mapping {row} {sr} {len(tables)}")
                allresults.append(
                    findmapping(
                        SR(row.target + (sr.startpoint - row.source),  row.endpoint - sr.startpoint),
                        tables,
                        prefix + "#",
                    )
                )
                if (sr.endpoint > row.endpoint):
                    print(f"{prefix}P32 Vana {sr}")
                    sr = SR(row.endpoint, sr.endpoint - row.endpoint)
                    print(f"{prefix}P32 Uus {sr}")
    if not otsas:
        allresults.append(findmapping(sr, tables, prefix + "#"))

    print(f"{prefix}Vastused")
    print(f"{prefix}{allresults}")
    return min(allresults)


with open("data.txt") as file:
    lines = [line.rstrip() for line in file]

tables = []
table = []
seeds = []
seedranges = []
for line in lines:
    if line == "":
        # print("Tühi rida")
        continue
    if line.startswith("seeds: "):
        temp = re.findall(r"\d+", line)
        seeds = list(map(int, temp))
        # print(len(seeds))
        for i in range(0, int(len(seeds) / 2)):
            seedranges.append(SR(seeds[i * 2], seeds[i * 2 + 1]))
        # print(seedranges)
        continue

    if line[0].isalpha():
        if len(table) > 0:
            tables.append(table)
            table = []
        continue

    temp = re.findall(r"\d+", line)
    tableitems = list(map(int, temp))
    table.append(Range(*tableitems))
tables.append(table)


# for table in tables:
#     #print("tabel")
#     for rida in table:
#         print(rida)

pisim = 0


print("########################")
print("####")
print(seedranges)
pisim = []
for sr in seedranges:
    pisim.append(findmapping(sr, tables, ""))


print(min(pisim))