import copy


class Soduku:
    """ A Soduku osztály """

    def __init__(self, x):
        """ Egy új Soduku osztály létrehozása """
        self.x = x
        self.mezok = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

    def __str__(self):  # objektum átalakítása stringgé
        kiir = ''
        for sor in self.x:
            for elem in sor:
                kiir += elem + ' '
            kiir += '\n'
        return kiir

    def sor_oszlop_ertek(self, s, o):
        """ Egy sor és egy oszlop metszéspontjában lévő érték """
        return self.x[s - 1][o - 1]

    def resztabla(self, s, o):
        """ Egy sor és egy oszlop metszéspontjában lévő értékheztartozó résztábla """
        return self.mezok[(s - 1) // 3][(o - 1) // 3]

    def ureshelyek_szama(self):
        """ Üres (0) helyek száma """
        db = 0
        for egysora in self.x:
            db += egysora.count('0')
        return db

    def helyek_szama(self):
        """ A Soduku mérete """
        return len(self.x) ** 2

    def kitoltott(self, s, o):
        """ Egy sor és egy oszlop metszéspontjában lévő hely kitöltöttsége """
        if self.x[s - 1][o - 1] != '0':
            return True
        else:
            return False

    def sorban_van(self, szam, s):
        """ Egy szám egy adott sorban ven-e """
        if szam in self.x[s - 1]:
            return True
        else:
            return False

    def oszlopban_van(self, szam, o):
        """ Egy szám egy adott oszlopban ven-e """
        van = False
        for sor in self.x:
            if sor[o - 1] == szam:
                van = True
                break
        return van

    def blokk_elemei(self, bsz):
        """ Egy blokk elemei """
        i = ((bsz - 1) // 3) * 3
        j = ((bsz - 1) % 3) * 3
        elemek = []
        for k in range(i, i + 3):
            for l in range(j, j + 3):
                elemek.append(self.x[k][l])
        return elemek

    def blokkban_van(self, szam, s, o):
        """ Egy szám egy megadott sor és oszlophoz tartozó blokkban van-e """
        van = False
        i = ((s - 1) // 3) * 3
        j = ((o - 1) // 3) * 3
        for k in range(i, i + 3):
            for l in range(j, j + 3):
                if szam == self.x[k][l]:
                    van = True
        return van

    def ureshelyek(self):
        """ Üres (0) helyeket adja meg sor oszlop azonosítóval """
        ures = []
        for i, egysora in enumerate(self.x):
            for j, elem in enumerate(egysora):
                if elem == '0':
                    ures.append((i + 1, j + 1))
        return ures

    def erteket_kap(self, szam, s, o):
        self.x[s - 1][o - 1] = str(szam)
        return True


    def vegrehajthato(self, szam, s, o):
        if not self.sorban_van(szam, s) and not self.oszlopban_van(szam, o) \
                and not self.blokkban_van(szam, s, o) and not self.kitoltott(s, o):
            return True
        else:
            return False

# 1. feladat
# adatok beolvasása
kiindulas = []
kitoltes = []
fajl = input("1. feladat\nAdja meg a bemeneti fájl nevét! ")
sor = int(input("Adja meg a sor számát! "))
oszlop = int(input("Adja meg az oszlop számát! "))
be = open(fajl)
i = 1
for egysor in be.readlines():
    if i < 10:
        kiindulas.append(egysor.split())
    else:
        kitoltes.append(egysor.split())
    i += 1
be.close()
# adatok beolvasás vége

so = Soduku(kiindulas)
# 3. feladat
print("3. feladat\nAz adott helyen szereplő szám:", so.sor_oszlop_ertek(sor, oszlop))
print("A hely a(z)", so.resztabla(sor, oszlop), "résztáblázathoz tartoz")

# 4. feladat
print("4. feladat\nAz üres helyek aránya: {:.1f}%".format(so.ureshelyek_szama() * 100 / so.helyek_szama()))

# 5. feladat
for szam, sor, oszlop in kitoltes:
    sor, oszlop = int(sor), int(oszlop)
    print("A kiválasztott sor:", sor, "oszlop:", oszlop, "a szám:", szam)
    if so.kitoltott(sor, oszlop):
        print("A helyet már kitöltötték.")
    elif so.sorban_van(szam, sor):
        print("Az adott sorban már szerepel a szám.")
    elif so.oszlopban_van(szam, oszlop):
        print("Az adott oszlopban már szerepel a szám.")
    elif so.blokkban_van(szam, sor, oszlop):
        print("A résztáblában már szerepel a szám.")
    else:
        print("A lépés megtehető.")