Untitled

From Beefy Penguin, 4 Years ago, written in Plain Text.

Embed

Download Paste or View Raw
Hits: 191

# -*- coding: utf-8 -*-

# import time

sudoku = input()

# t1 = time.time()

sudoku = sudoku.replace(" ", "")

liczba_pion = 0

liczba_poziom = 0

liczba_klatka = 0

pion = [[], [], [], [], [], [], [], [], []]

poziom = [[], [], [], [], [], [], [], [], []]

klatka = [[], [], [], [], [], [], [], [], []]

# wczytanie liczb z sudoku do poziomu--------------------------------------------------------------------

for i, cyfry in enumerate(sudoku):

if i % 9 == 0 and i != 0:

liczba_poziom += 1

if liczba_poziom == 9:

liczba_poziom = 8

break

poziom[liczba_poziom].append(cyfry)

# wejscie w uzupełnianie sudoku----------------------------------------------------------------------------------

while ('.' in poziom[0] or '.' in poziom[1] or '.' in poziom[2] or

'.' in poziom[3] or '.' in poziom[4] or '.' in poziom[5] or

'.' in poziom[6] or '.' in poziom[7] or '.' in poziom[8] ):

if len(sudoku) != 81:

break

print()

for z in pion:

print(z)

print()

for i in range(81):

# wyczyszczenie pozostalej zawartosci z tablic

for n in range(9):

del klatka[n][0:]

del pion[n][0:]

#wczytanie z poziomu dp pionu i posegregowanie na klatki

for x,l in enumerate(poziom):

for j, liczby in enumerate(poziom[x]):

if (j == 0 or j == 1 or j == 2) and x <= 2:

klatka[0].append(liczby)

elif (j == 3 or j == 4 or j == 5) and x <= 2:

klatka[1].append(liczby)

elif (j == 6 or j == 7 or j == 8) and x <= 2:

klatka[2].append(liczby)

elif (j == 0 or j == 1 or j == 2) and (x > 2 and x <= 5):

klatka[3].append(liczby)

elif (j == 3 or j == 4 or j == 5) and (x > 2 and x <= 5):

klatka[4].append(liczby)

elif (j == 6 or j == 7 or j == 8) and (x > 2 and x <= 5):

klatka[5].append(liczby)

elif (j == 0 or j == 1 or j == 2) and (x > 5 and x <= 8):

klatka[6].append(liczby)

elif (j == 3 or j == 4 or j == 5) and (x > 5 and x <= 8):

klatka[7].append(liczby)

elif (j == 6 or j == 7 or j == 8) and (x > 5 and x <= 8):

klatka[8].append(liczby)

pion[j].append(liczby)

# w zaleznosci od i dopasowanie do klatki poziomu i pionu

if (

i == 0

or i == 1

or i == 2

or i == 9

or i == 10

or i == 11

or i == 18

or i == 19

or i == 20

):

liczba_klatka = 0

if i == 0 or i == 1 or i == 2:

liczba_poziom = 0

elif i == 9 or i == 10 or i == 11:

liczba_poziom = 1

elif i == 18 or i == 19 or i == 20:

liczba_poziom = 2

if i % 3 == 0:

liczba_pion = 0

elif i % 3 == 1:

liczba_pion = 1

elif i % 3 == 2:

liczba_pion = 2

elif (

i == 3

or i == 4

or i == 5

or i == 12

or i == 13

or i == 14

or i == 21

or i == 22

or i == 23

):

liczba_klatka = 1

if i == 3 or i == 4 or i == 5:

liczba_poziom = 0

elif i == 12 or i == 13 or i == 14:

liczba_poziom = 1

elif i == 21 or i == 22 or i == 23:

liczba_poziom = 2

if i % 3 == 0:

liczba_pion = 3

elif i % 3 == 1:

liczba_pion = 4

elif i % 3 == 2:

liczba_pion = 5

elif (

i == 6

or i == 7

or i == 8

or i == 15

or i == 16

or i == 17

or i == 24

or i == 25

or i == 26

):

liczba_klatka = 2

if i == 6 or i == 7 or i == 8:

liczba_poziom = 0

elif i == 15 or i == 16 or i == 17:

liczba_poziom = 1

elif i == 24 or i == 25 or i == 26:

liczba_poziom = 2

if i % 3 == 0:

liczba_pion = 6

elif i % 3 == 1:

liczba_pion = 7

elif i % 3 == 2:

liczba_pion = 8

# ------------------------------------------------------------------------------------------------------------------

elif (

i == 27

or i == 28

or i == 29

or i == 36

or i == 37

or i == 38

or i == 45

or i == 46

or i == 47

):

liczba_klatka = 3

if i == 27 or i == 28 or i == 29:

liczba_poziom = 3

elif i == 36 or i == 37 or i == 38:

liczba_poziom = 4

elif i == 47 or i == 46 or i == 45:

liczba_poziom = 5

if i % 3 == 0:

liczba_pion = 0

elif i % 3 == 1:

liczba_pion = 1

elif i % 3 == 2:

liczba_pion = 2

elif (

i == 30

or i == 31

or i == 32

or i == 39

or i == 40

or i == 41

or i == 48

or i == 49

or i == 50

):

liczba_klatka = 4

if i == 30 or i == 31 or i == 32:

liczba_poziom = 3

elif i == 39 or i == 40 or i == 41:

liczba_poziom = 4

elif i == 48 or i == 49 or i == 50:

liczba_poziom = 5

if i % 3 == 0:

liczba_pion = 3

elif i % 3 == 1:

liczba_pion = 4

elif i % 3 == 2:

liczba_pion = 5

elif (

i == 33

or i == 34

or i == 35

or i == 42

or i == 43

or i == 44

or i == 51

or i == 52

or i == 53

):

liczba_klatka = 5

if i == 33 or i == 34 or i == 35:

liczba_poziom = 3

elif i == 42 or i == 43 or i == 44:

liczba_poziom = 4

elif i == 51 or i == 52 or i == 53:

liczba_poziom = 5

if i % 3 == 0:

liczba_pion = 6

elif i % 3 == 1:

liczba_pion = 7

elif i % 3 == 2:

liczba_pion = 8

# -----------------------------------------------------------------------------------------------------------------

elif (

i == 54

or i == 55

or i == 56

or i == 63

or i == 64

or i == 65

or i == 72

or i == 73

or i == 74

):

liczba_klatka = 6

if i == 54 or i == 55 or i == 56:

liczba_poziom = 6

elif i == 63 or i == 64 or i == 65:

liczba_poziom = 7

elif i == 72 or i == 73 or i == 74:

liczba_poziom = 8

if i % 3 == 0:

liczba_pion = 0

elif i % 3 == 1:

liczba_pion = 1

elif i % 3 == 2:

liczba_pion = 2

elif (

i == 57

or i == 58

or i == 59

or i == 66

or i == 67

or i == 68

or i == 75

or i == 76

or i == 77

):

liczba_klatka = 7

if i == 57 or i == 58 or i == 59:

liczba_poziom = 6

elif i == 66 or i == 67 or i == 68:

liczba_poziom = 7

elif i == 75 or i == 76 or i == 77:

liczba_poziom = 8

if i % 3 == 0:

liczba_pion = 3

elif i % 3 == 1:

liczba_pion = 4

elif i % 3 == 2:

liczba_pion = 5

elif (

i == 60

or i == 61

or i == 62

or i == 69

or i == 70

or i == 71

or i == 78

or i == 79

or i == 80

):

liczba_klatka = 8

if i == 60 or i == 61 or i == 62:

liczba_poziom = 6

elif i == 69 or i == 70 or i == 71:

liczba_poziom = 7

elif i == 78 or i == 79 or i == 80:

liczba_poziom = 8

if i % 3 == 0:

liczba_pion = 6

elif i % 3 == 1:

liczba_pion = 7

elif i % 3 == 2:

liczba_pion = 8

#----------------------------------------------------------------------------------------------------------

# wejscie do petli z warunkami kotre liczba musi spelnic liczby ida od 1 do 9 i po kolei sa srawdzane

for x in range(1, 10):

j = str(x)

if j in klatka[liczba_klatka]:

continue

if j in poziom[liczba_poziom]:

continue

if j in pion[liczba_pion]:

continue

if poziom[liczba_poziom][i%9] != '.':

break

if liczba_pion % 3 == 0:

if liczba_poziom % 3 == 0:

# warunek z dwiema cyframi------------------------------------------------------------------

if (

klatka[liczba_klatka][3] != "."

and klatka[liczba_klatka][6] != "."

and (j in pion[liczba_pion + 1])

and (j in pion[liczba_pion + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][1] != "."

and klatka[liczba_klatka][2] != "."

and (j in poziom[liczba_poziom + 1])

and (j in poziom[liczba_poziom + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z jedna cyfra---------------------------------------------------------------------

elif (

(j in poziom[liczba_poziom + 1])

and (j in poziom[liczba_poziom + 2])

and (j in pion[liczba_pion + 1])

and klatka[liczba_klatka][2] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in poziom[liczba_poziom + 1])

and (j in poziom[liczba_poziom + 2])

and (j in pion[liczba_pion + 2])

and klatka[liczba_klatka][1] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in pion[liczba_pion + 1])

and (j in pion[liczba_pion + 2])

and (j in poziom[liczba_poziom + 1])

and klatka[liczba_klatka][6] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in pion[liczba_pion + 1])

and (j in pion[liczba_pion + 2])

and (j in poziom[liczba_poziom + 2])

and klatka[liczba_klatka][3] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in poziom[liczba_poziom + 2])

and (j in poziom[liczba_poziom + 1])

and (j in pion[liczba_pion + 1])

and (j in pion[liczba_pion + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z pięcioma cyframi-----------------------------------------------------------------

elif (

klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][8] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][6] != '.'

and (j in pion[liczba_pion + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][6] != '.'

and (j in pion[liczba_pion + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and (j in poziom[liczba_poziom + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z trzema cyframi -------------------------------------------------------------

elif (

klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom + 1])

and (j in pion[liczba_pion + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

and (j in poziom[liczba_poziom + 1])

and (j in pion[liczba_pion + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and (j in poziom[liczba_poziom + 2])

and (j in pion[liczba_pion + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][3] != '.'

and (j in poziom[liczba_poziom + 2])

and (j in pion[liczba_pion + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z ostatnia cyfra--------------------------------------------------------------

#klatka

elif (

j not in klatka[liczba_klatka]

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][8] != '.'

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

#???????????????????????????????????????????????????????????????????????????????????????????

elif liczba_poziom % 3 == 1:

# warunek z dwiema cyframi-------------------------------------------------------------------

if (

klatka[liczba_klatka][4] != "."

and klatka[liczba_klatka][5] != "."

and (j in poziom[liczba_poziom - 1])

and (j in poziom[liczba_poziom + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != "."

and klatka[liczba_klatka][6] != "."

and (j in pion[liczba_pion + 1])

and (j in pion[liczba_pion + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z jedna cyfra---------------------------------------------------------------------

elif (

(j in poziom[liczba_poziom + 1])

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion + 2])

and klatka[liczba_klatka][4] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in poziom[liczba_poziom + 1])

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion + 1])

and klatka[liczba_klatka][5] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in pion[liczba_pion + 1])

and (j in pion[liczba_pion + 2])

and (j in poziom[liczba_poziom + 1])

and klatka[liczba_klatka][0] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in pion[liczba_pion + 1])

and (j in pion[liczba_pion + 2])

and (j in poziom[liczba_poziom - 1])

and klatka[liczba_klatka][6] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in poziom[liczba_poziom - 1])

and (j in poziom[liczba_poziom + 1])

and (j in pion[liczba_pion + 1])

and (j in pion[liczba_pion + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z pięcioma cyframi-----------------------------------------------------------------

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in pion[liczba_pion + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and (j in poziom[liczba_poziom + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

and (j in pion[liczba_pion + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z trzema cyframi -------------------------------------------------------------

elif (

klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][5] != '.'

and (j in poziom[liczba_poziom + 1])

and (j in pion[liczba_pion + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][4] != '.'

and (j in poziom[liczba_poziom + 1])

and (j in pion[liczba_pion + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z ostatnia cyfra--------------------------------------------------------------

#klatka

elif (

j not in klatka[liczba_klatka]

and klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][8] != '.'

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

#???????????????????????????????????????????????????????????????????????????????????????????

elif liczba_poziom % 3 == 2:

# warunek z dwoma cyframi-----------------------------------------------------------------

if (

klatka[liczba_klatka][3] != "."

and klatka[liczba_klatka][0] != "."

and (j in pion[liczba_pion + 1])

and (j in pion[liczba_pion + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][8] != "."

and klatka[liczba_klatka][7] != "."

and (j in poziom[liczba_poziom - 1])

and (j in poziom[liczba_poziom - 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z jedna cyfra-----------------------------------------------------------------

elif (

(j in poziom[liczba_poziom - 1])

and (j in poziom[liczba_poziom - 2])

and (j in pion[liczba_pion + 1])

and klatka[liczba_klatka][8] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in poziom[liczba_poziom - 1])

and (j in poziom[liczba_poziom - 2])

and (j in pion[liczba_pion + 2])

and klatka[liczba_klatka][7] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in pion[liczba_pion + 1])

and (j in pion[liczba_pion + 2])

and (j in poziom[liczba_poziom - 1])

and klatka[liczba_klatka][0] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in pion[liczba_pion + 1])

and (j in pion[liczba_pion + 2])

and (j in poziom[liczba_poziom - 2])

and klatka[liczba_klatka][3] != '.'

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in poziom[liczba_poziom - 2])

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion + 1])

and (j in pion[liczba_pion + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z pięcioma cyframi-----------------------------------------------------------------

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in pion[liczba_pion + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom - 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][7] != '.'

and (j in pion[liczba_pion + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z trzema cyframi -------------------------------------------------------------

elif (

klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom - 2])

and (j in pion[liczba_pion + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][7] != '.'

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][7] != '.'

and (j in poziom[liczba_poziom - 2])

and (j in pion[liczba_pion + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z ostatnia cyfra--------------------------------------------------------------

#klatka

elif (

j not in klatka[liczba_klatka]

and klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][8] != '.'

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

#???????????????????????????????????????????????????????????????????????????????????????????

# --------------------------------------------------------------------------------------------------

elif liczba_pion % 3 == 1:

if liczba_poziom % 3 == 0:

# warunek z dwiema cyframi-----------------------------------------------------------------

if (

klatka[liczba_klatka][4] != "."

and klatka[liczba_klatka][7] != "."

and (j in pion[liczba_pion + 1])

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][2] != "."

and klatka[liczba_klatka][0] != "."

and (j in poziom[liczba_poziom + 1])

and (j in poziom[liczba_poziom + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z jedna cyfra-----------------------------------------------------------------

elif (

(j in poziom[liczba_poziom + 1])

and (j in poziom[liczba_poziom + 2])

and (j in pion[liczba_pion + 1])

and klatka[liczba_klatka][0] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in poziom[liczba_poziom + 1])

and (j in poziom[liczba_poziom + 2])

and (j in pion[liczba_pion - 1])

and klatka[liczba_klatka][2] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in pion[liczba_pion + 1])

and (j in pion[liczba_pion - 1])

and (j in poziom[liczba_poziom + 2])

and klatka[liczba_klatka][4] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in pion[liczba_pion + 1])

and (j in pion[liczba_pion - 1])

and (j in poziom[liczba_poziom + 1])

and klatka[liczba_klatka][7] != '.'

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in poziom[liczba_poziom + 2])

and (j in poziom[liczba_poziom + 1])

and (j in pion[liczba_pion + 1])

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z pięcioma cyframi-----------------------------------------------------------------

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

and (j in pion[liczba_pion + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and (j in poziom[liczba_poziom + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z trzema cyframi -------------------------------------------------------------

elif (

klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom + 1])

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and (j in poziom[liczba_poziom + 2])

and (j in pion[liczba_pion + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and (j in poziom[liczba_poziom + 2])

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

and (j in poziom[liczba_poziom + 1])

and (j in pion[liczba_pion + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z ostatnia cyfra--------------------------------------------------------------

#klatka

elif (

j not in klatka[liczba_klatka]

and klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][8] != '.'

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

#???????????????????????????????????????????????????????????????????????????????????????????

elif liczba_poziom % 3 == 1:

# warunek z dwiema cyframi-----------------------------------------------------------------

if (

klatka[liczba_klatka][1] != "."

and klatka[liczba_klatka][7] != "."

and (j in pion[liczba_pion + 1])

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][5] != "."

and klatka[liczba_klatka][3] != "."

and (j in poziom[liczba_poziom + 1])

and (j in poziom[liczba_poziom - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z jedna cyfra-----------------------------------------------------------------

elif (

(j in poziom[liczba_poziom + 1])

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion - 1])

and klatka[liczba_klatka][5] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in poziom[liczba_poziom + 1])

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion + 1])

and klatka[liczba_klatka][3] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in pion[liczba_pion + 1])

and (j in pion[liczba_pion - 1])

and (j in poziom[liczba_poziom + 1])

and klatka[liczba_klatka][1] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in pion[liczba_pion + 1])

and (j in pion[liczba_pion - 1])

and (j in poziom[liczba_poziom - 1])

and klatka[liczba_klatka][7] != '.'

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in poziom[liczba_poziom + 1])

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion + 1])

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z pięcioma cyframi-----------------------------------------------------------------

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

and (j in pion[liczba_pion + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][5] != '.'

and (j in poziom[liczba_poziom + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][8] != '.'

and klatka[liczba_klatka][7] != '.'

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z trzema cyframi -------------------------------------------------------------

elif (

klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][8] != '.'

and klatka[liczba_klatka][7] != '.'

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][5] != '.'

and (j in poziom[liczba_poziom + 1])

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][3] != '.'

and (j in poziom[liczba_poziom + 1])

and (j in pion[liczba_pion + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z ostatnia cyfra--------------------------------------------------------------

#klatka

elif (

j not in klatka[liczba_klatka]

and klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][8] != '.'

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

#???????????????????????????????????????????????????????????????????????????????????????????

elif liczba_poziom % 3 == 2:

# warunek z dwiema cyframi-----------------------------------------------------------------

if (

klatka[liczba_klatka][1] != "."

and klatka[liczba_klatka][4] != "."

and (j in pion[liczba_pion + 1])

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][8] != "."

and klatka[liczba_klatka][6] != "."

and (j in poziom[liczba_poziom - 1])

and (j in poziom[liczba_poziom - 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z jedna cyfra-----------------------------------------------------------------

elif (

(j in poziom[liczba_poziom - 1])

and (j in poziom[liczba_poziom - 2])

and (j in pion[liczba_pion - 1])

and klatka[liczba_klatka][8] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in poziom[liczba_poziom - 1])

and (j in poziom[liczba_poziom - 2])

and (j in pion[liczba_pion + 1])

and klatka[liczba_klatka][6] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in pion[liczba_pion + 1])

and (j in pion[liczba_pion - 1])

and (j in poziom[liczba_poziom - 1])

and klatka[liczba_klatka][1] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in pion[liczba_pion + 1])

and (j in pion[liczba_pion - 1])

and (j in poziom[liczba_poziom - 2])

and klatka[liczba_klatka][4] != '.'

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in poziom[liczba_poziom - 1])

and (j in poziom[liczba_poziom - 2])

and (j in pion[liczba_pion + 1])

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z pięcioma cyframi-----------------------------------------------------------------

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][6] != '.'

and (j in pion[liczba_pion + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom - 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z trzema cyframi -------------------------------------------------------------

elif (

klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom - 2])

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][6] != '.'

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][6] != '.'

and (j in poziom[liczba_poziom - 2])

and (j in pion[liczba_pion + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z ostatnia cyfra--------------------------------------------------------------

#klatka

elif (

j not in klatka[liczba_klatka]

and klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][8] != '.'

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

#???????????????????????????????????????????????????????????????????????????????????????????

# ---------------------------------------------------------------------------------------------------

elif liczba_pion % 3 == 2:

if liczba_poziom % 3 == 0:

# warunek z dwiema cyframi-----------------------------------------------------------------

if (

klatka[liczba_klatka][5] != "."

and klatka[liczba_klatka][8] != "."

and (j in pion[liczba_pion - 1])

and (j in pion[liczba_pion - 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != "."

and klatka[liczba_klatka][1] != "."

and (j in poziom[liczba_poziom + 1])

and (j in poziom[liczba_poziom + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z jedna cyfra-----------------------------------------------------------------

elif (

(j in poziom[liczba_poziom + 1])

and (j in poziom[liczba_poziom + 2])

and (j in pion[liczba_pion - 1])

and klatka[liczba_klatka][0] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in poziom[liczba_poziom + 1])

and (j in poziom[liczba_poziom + 2])

and (j in pion[liczba_pion - 2])

and klatka[liczba_klatka][1] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in pion[liczba_pion - 1])

and (j in pion[liczba_pion - 2])

and (j in poziom[liczba_poziom + 1])

and klatka[liczba_klatka][8] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in pion[liczba_pion - 1])

and (j in pion[liczba_pion - 2])

and (j in poziom[liczba_poziom + 2])

and klatka[liczba_klatka][5] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in poziom[liczba_poziom + 1])

and (j in poziom[liczba_poziom + 2])

and (j in pion[liczba_pion - 1])

and (j in pion[liczba_pion - 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z pięcioma cyframi-----------------------------------------------------------------

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in pion[liczba_pion - 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom + 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and (j in poziom[liczba_poziom + 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z trzema cyframi -------------------------------------------------------------

elif (

klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom + 1])

and (j in pion[liczba_pion - 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and (j in poziom[liczba_poziom + 2])

and (j in pion[liczba_pion - 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][5] != '.'

and (j in poziom[liczba_poziom + 2])

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom + 1])

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z ostatnia cyfra--------------------------------------------------------------

#klatka

elif (

j not in klatka[liczba_klatka]

and klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][8] != '.'

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

#???????????????????????????????????????????????????????????????????????????????????????????

elif liczba_poziom % 3 == 1:

# warunek z dwiema cyframi-----------------------------------------------------------------

if (

klatka[liczba_klatka][2] != "."

and klatka[liczba_klatka][8] != "."

and (j in pion[liczba_pion - 1])

and (j in pion[liczba_pion - 2])

):

print('1',i)

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][4] != "."

and klatka[liczba_klatka][3] != "."

and (j in poziom[liczba_poziom - 1])

and (j in poziom[liczba_poziom + 1])

):

print('2',i)

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z jedna cyfra-----------------------------------------------------------------

elif (

(j in poziom[liczba_poziom + 1])

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion - 1])

and klatka[liczba_klatka][3] != "."

):

print('3',i)

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in poziom[liczba_poziom - 1])

and (j in poziom[liczba_poziom + 1])

and (j in pion[liczba_pion - 2])

and klatka[liczba_klatka][4] != "."

):

print('4',i)

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in pion[liczba_pion - 1])

and (j in pion[liczba_pion - 2])

and (j in poziom[liczba_poziom + 1])

and klatka[liczba_klatka][2] != "."

):

print('5',i)

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in pion[liczba_pion - 1])

and (j in pion[liczba_pion - 2])

and (j in poziom[liczba_poziom - 1])

and klatka[liczba_klatka][8] != '.'

):

print('6',i)

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in poziom[liczba_poziom + 1])

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion - 1])

and (j in pion[liczba_pion - 2])

):

print('7',i)

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z pięcioma cyframi-----------------------------------------------------------------

elif (

klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][8] != '.'

and klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][6] != '.'

and (j in pion[liczba_pion - 1])

):

print('8',i)

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in pion[liczba_pion - 2])

):

print('9',i)

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and (j in poziom[liczba_poziom + 1])

):

print('10',i)

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom - 1])

):

print('11',i)

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z trzema cyframi -------------------------------------------------------------

elif (

klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][7] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion - 2])

):

print('12',i)

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][4] != '.'

and (j in poziom[liczba_poziom + 1])

and (j in pion[liczba_pion - 2])

):

print('13',i)

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][8] != '.'

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion - 1])

):

print('14',i)

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][2] != '.'

and (j in poziom[liczba_poziom + 1])

and (j in pion[liczba_pion - 1])

):

print('15',i)

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z ostatnia cyfra--------------------------------------------------------------

#???????????????????????????????????????????????????????????????????????????????????????????

elif liczba_poziom % 3 == 2:

# warunek z dwiema cyframi-----------------------------------------------------------------

if (

klatka[liczba_klatka][2] != "."

and klatka[liczba_klatka][5] != "."

and (j in pion[liczba_pion - 1])

and (j in pion[liczba_pion - 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][6] != "."

and klatka[liczba_klatka][7] != "."

and (j in poziom[liczba_poziom - 1])

and (j in poziom[liczba_poziom - 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z jedna cyfra-----------------------------------------------------------------

elif (

(j in poziom[liczba_poziom - 1])

and (j in poziom[liczba_poziom - 2])

and (j in pion[liczba_pion - 1])

and klatka[liczba_klatka][6] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in poziom[liczba_poziom - 1])

and (j in poziom[liczba_poziom - 2])

and (j in pion[liczba_pion - 2])

and klatka[liczba_klatka][7] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in pion[liczba_pion - 1])

and (j in pion[liczba_pion - 2])

and (j in poziom[liczba_poziom - 1])

and klatka[liczba_klatka][2] != "."

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in pion[liczba_pion - 1])

and (j in pion[liczba_pion - 2])

and (j in poziom[liczba_poziom - 2])

and klatka[liczba_klatka][5] != '.'

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

(j in poziom[liczba_poziom - 2])

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion - 1])

and (j in pion[liczba_pion - 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z pięcioma cyframi-----------------------------------------------------------------

elif (

klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][6] != '.'

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][7] != '.'

and (j in pion[liczba_pion - 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

and (j in poziom[liczba_poziom - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

and (j in poziom[liczba_poziom - 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z trzema cyframi -------------------------------------------------------------

elif (

klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][7] != '.'

and (j in poziom[liczba_poziom - 2])

and (j in pion[liczba_pion - 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][7] != '.'

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion - 2])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][6] != '.'

and (j in poziom[liczba_poziom - 2])

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

elif (

klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][6] != '.'

and (j in poziom[liczba_poziom - 1])

and (j in pion[liczba_pion - 1])

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

# warunek z ostatnia cyfra--------------------------------------------------------------

#klatka

elif (

j not in klatka[liczba_klatka]

and klatka[liczba_klatka][0] != '.'

and klatka[liczba_klatka][1] != '.'

and klatka[liczba_klatka][2] != '.'

and klatka[liczba_klatka][3] != '.'

and klatka[liczba_klatka][4] != '.'

and klatka[liczba_klatka][5] != '.'

and klatka[liczba_klatka][6] != '.'

and klatka[liczba_klatka][7] != '.'

):

poziom[liczba_poziom].pop(i%9)

poziom[liczba_poziom].insert(i%9,j)

#???????????????????????????????????????????????????????????????????????????????????????????

for z in poziom:

print(z)

Author

Title

Language

Your paste - Paste your paste here

# -*- coding: utf-8 -*-
# import time

sudoku = input()
# t1 = time.time()
sudoku = sudoku.replace(&quot; &quot;, &quot;&quot;)

liczba_pion = 0
liczba_poziom = 0
liczba_klatka = 0

pion = [[], [], [], [], [], [], [], [], []]
poziom = [[], [], [], [], [], [], [], [], []]
klatka = [[], [], [], [], [], [], [], [], []]

# wczytanie liczb z sudoku do poziomu--------------------------------------------------------------------

for i, cyfry in enumerate(sudoku):

if i % 9 == 0 and i != 0:

liczba_poziom += 1

if liczba_poziom == 9:

liczba_poziom = 8
            break

poziom[liczba_poziom].append(cyfry)

# wejscie w uzupełnianie sudoku----------------------------------------------------------------------------------
while ('.' in poziom[0] or '.' in poziom[1] or '.' in poziom[2] or
'.' in poziom[3] or '.' in poziom[4] or '.' in poziom[5] or
'.' in poziom[6] or '.' in poziom[7] or '.' in poziom[8] ):
    if len(sudoku) != 81:
        break
    print()
    for z in pion:
        print(z)
    print()

for i in range(81):

# wyczyszczenie pozostalej zawartosci z tablic 
        for n in range(9):
            del klatka[n][0:]
            del pion[n][0:]

#wczytanie z poziomu dp pionu i posegregowanie na klatki
    
        for x,l in enumerate(poziom):
            for j, liczby in enumerate(poziom[x]):

if (j == 0 or j == 1 or j == 2) and x &lt;= 2:
                    klatka[0].append(liczby)
                elif (j == 3 or j == 4 or j == 5) and x &lt;= 2:
                    klatka[1].append(liczby)
                elif (j == 6 or j == 7 or j == 8) and x &lt;= 2:
                    klatka[2].append(liczby)
                elif (j == 0 or j == 1 or j == 2) and (x &gt; 2 and x &lt;= 5):
                    klatka[3].append(liczby)
                elif (j == 3 or j == 4 or j == 5) and (x &gt; 2 and x &lt;= 5):
                    klatka[4].append(liczby)
                elif (j == 6 or j == 7 or j == 8) and (x &gt; 2 and x &lt;= 5):
                    klatka[5].append(liczby)
                elif (j == 0 or j == 1 or j == 2) and (x &gt; 5 and x &lt;= 8):
                    klatka[6].append(liczby)
                elif (j == 3 or j == 4 or j == 5) and (x &gt; 5 and x &lt;= 8):
                    klatka[7].append(liczby)
                elif (j == 6 or j == 7 or j == 8) and (x &gt; 5 and x &lt;= 8):
                    klatka[8].append(liczby)

pion[j].append(liczby)

# w zaleznosci od i dopasowanie do klatki poziomu i pionu
        if (
            i == 0
            or i == 1
            or i == 2
            or i == 9
            or i == 10
            or i == 11
            or i == 18
            or i == 19
            or i == 20
        ):

liczba_klatka = 0

if i == 0 or i == 1 or i == 2:
                liczba_poziom = 0
            elif i == 9 or i == 10 or i == 11:
                liczba_poziom = 1
            elif i == 18 or i == 19 or i == 20:
                liczba_poziom = 2

if i % 3 == 0:
                liczba_pion = 0
            elif i % 3 == 1:
                liczba_pion = 1
            elif i % 3 == 2:
                liczba_pion = 2

elif (
            i == 3
            or i == 4
            or i == 5
            or i == 12
            or i == 13
            or i == 14
            or i == 21
            or i == 22
            or i == 23
        ):

liczba_klatka = 1

if i == 3 or i == 4 or i == 5:
                liczba_poziom = 0
            elif i == 12 or i == 13 or i == 14:
                liczba_poziom = 1
            elif i == 21 or i == 22 or i == 23:
                liczba_poziom = 2

if i % 3 == 0:
                liczba_pion = 3
            elif i % 3 == 1:
                liczba_pion = 4
            elif i % 3 == 2:
                liczba_pion = 5

elif (
            i == 6
            or i == 7
            or i == 8
            or i == 15
            or i == 16
            or i == 17
            or i == 24
            or i == 25
            or i == 26
        ):

liczba_klatka = 2

if i == 6 or i == 7 or i == 8:
                liczba_poziom = 0
            elif i == 15 or i == 16 or i == 17:
                liczba_poziom = 1
            elif i == 24 or i == 25 or i == 26:
                liczba_poziom = 2

if i % 3 == 0:
                liczba_pion = 6
            elif i % 3 == 1:
                liczba_pion = 7
            elif i % 3 == 2:
                liczba_pion = 8
        # ------------------------------------------------------------------------------------------------------------------
        elif (
            i == 27
            or i == 28
            or i == 29
            or i == 36
            or i == 37
            or i == 38
            or i == 45
            or i == 46
            or i == 47
        ):

liczba_klatka = 3

if i == 27 or i == 28 or i == 29:
                liczba_poziom = 3
            elif i == 36 or i == 37 or i == 38:
                liczba_poziom = 4
            elif i == 47 or i == 46 or i == 45:
                liczba_poziom = 5

if i % 3 == 0:
                liczba_pion = 0
            elif i % 3 == 1:
                liczba_pion = 1
            elif i % 3 == 2:
                liczba_pion = 2

elif (
            i == 30
            or i == 31
            or i == 32
            or i == 39
            or i == 40
            or i == 41
            or i == 48
            or i == 49
            or i == 50
        ):

liczba_klatka = 4

if i == 30 or i == 31 or i == 32:
                liczba_poziom = 3
            elif i == 39 or i == 40 or i == 41:
                liczba_poziom = 4
            elif i == 48 or i == 49 or i == 50:
                liczba_poziom = 5

if i % 3 == 0:
                liczba_pion = 3
            elif i % 3 == 1:
                liczba_pion = 4
            elif i % 3 == 2:
                liczba_pion = 5

elif (
            i == 33
            or i == 34
            or i == 35
            or i == 42
            or i == 43
            or i == 44
            or i == 51
            or i == 52
            or i == 53
        ):

liczba_klatka = 5

if i == 33 or i == 34 or i == 35:
                liczba_poziom = 3
            elif i == 42 or i == 43 or i == 44:
                liczba_poziom = 4
            elif i == 51 or i == 52 or i == 53:
                liczba_poziom = 5

if i % 3 == 0:
                liczba_pion = 6
            elif i % 3 == 1:
                liczba_pion = 7
            elif i % 3 == 2:
                liczba_pion = 8

# -----------------------------------------------------------------------------------------------------------------

elif (
            i == 54
            or i == 55
            or i == 56
            or i == 63
            or i == 64
            or i == 65
            or i == 72
            or i == 73
            or i == 74
        ):

liczba_klatka = 6

if i == 54 or i == 55 or i == 56:
                liczba_poziom = 6
            elif i == 63 or i == 64 or i == 65:
                liczba_poziom = 7
            elif i == 72 or i == 73 or i == 74:
                liczba_poziom = 8

if i % 3 == 0:
                liczba_pion = 0
            elif i % 3 == 1:
                liczba_pion = 1
            elif i % 3 == 2:
                liczba_pion = 2

elif (
            i == 57
            or i == 58
            or i == 59
            or i == 66
            or i == 67
            or i == 68
            or i == 75
            or i == 76
            or i == 77
        ):

liczba_klatka = 7

if i == 57 or i == 58 or i == 59:
                liczba_poziom = 6
            elif i == 66 or i == 67 or i == 68:
                liczba_poziom = 7
            elif i == 75 or i == 76 or i == 77:
                liczba_poziom = 8

if i % 3 == 0:
                liczba_pion = 3
            elif i % 3 == 1:
                liczba_pion = 4
            elif i % 3 == 2:
                liczba_pion = 5

elif (
            i == 60
            or i == 61
            or i == 62
            or i == 69
            or i == 70
            or i == 71
            or i == 78
            or i == 79
            or i == 80
        ):

liczba_klatka = 8

if i == 60 or i == 61 or i == 62:
                liczba_poziom = 6
            elif i == 69 or i == 70 or i == 71:
                liczba_poziom = 7
            elif i == 78 or i == 79 or i == 80:
                liczba_poziom = 8

if i % 3 == 0:
                liczba_pion = 6
            elif i % 3 == 1:
                liczba_pion = 7
            elif i % 3 == 2:
                liczba_pion = 8

#----------------------------------------------------------------------------------------------------------
# wejscie do petli z warunkami kotre liczba musi spelnic liczby ida od 1 do 9 i po kolei sa srawdzane

for x in range(1, 10):
            j = str(x)

if j in klatka[liczba_klatka]:
                continue
            if j in poziom[liczba_poziom]:
                continue
            if j in pion[liczba_pion]:
                continue
            if poziom[liczba_poziom][i%9] != '.':
                break

if liczba_pion % 3 == 0:

if liczba_poziom % 3 == 0:

# warunek z dwiema cyframi------------------------------------------------------------------

if (
                        klatka[liczba_klatka][3] != &quot;.&quot;
                        and klatka[liczba_klatka][6] != &quot;.&quot;
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                    ):
                   
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][1] != &quot;.&quot;
                        and klatka[liczba_klatka][2] != &quot;.&quot;
                        and (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom + 2])
                    ):
                      
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z jedna cyfra---------------------------------------------------------------------

elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion + 1])
                        and klatka[liczba_klatka][2] != &quot;.&quot;
                    ):
                       
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                    elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion + 2])
                        and klatka[liczba_klatka][1] != &quot;.&quot;
                    ):
              
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                        and (j in poziom[liczba_poziom + 1])
                        and klatka[liczba_klatka][6] != &quot;.&quot;
                    ):
                
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                        and (j in poziom[liczba_poziom + 2])
                        and klatka[liczba_klatka][3] != &quot;.&quot;
                    ):
              
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in poziom[liczba_poziom + 2])
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z pięcioma cyframi-----------------------------------------------------------------
                   
                    elif (
                        klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and (j in pion[liczba_pion + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and (j in poziom[liczba_poziom + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z trzema cyframi -------------------------------------------------------------

elif (
                        klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z ostatnia cyfra--------------------------------------------------------------
                    
                    #klatka
                    elif (
                        j not in klatka[liczba_klatka] 
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

#???????????????????????????????????????????????????????????????????????????????????????????

elif liczba_poziom % 3 == 1:

# warunek z dwiema cyframi-------------------------------------------------------------------

if (
                        klatka[liczba_klatka][4] != &quot;.&quot;
                        and klatka[liczba_klatka][5] != &quot;.&quot;
                        and (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][0] != &quot;.&quot;
                        and klatka[liczba_klatka][6] != &quot;.&quot;
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z jedna cyfra---------------------------------------------------------------------

elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 2])
                        and klatka[liczba_klatka][4] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 1])
                        and klatka[liczba_klatka][5] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                        and (j in poziom[liczba_poziom + 1])
                        and klatka[liczba_klatka][0] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                        and (j in poziom[liczba_poziom - 1])
                        and klatka[liczba_klatka][6] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                    
                    # warunek z pięcioma cyframi-----------------------------------------------------------------
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and (j in poziom[liczba_poziom + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in pion[liczba_pion + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z trzema cyframi -------------------------------------------------------------

elif (
                        klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z ostatnia cyfra--------------------------------------------------------------
                    
                    #klatka
                    elif (
                        j not in klatka[liczba_klatka] 
                        and klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

#???????????????????????????????????????????????????????????????????????????????????????????

elif liczba_poziom % 3 == 2:
                    
                    # warunek z dwoma cyframi-----------------------------------------------------------------

if (
                        klatka[liczba_klatka][3] != &quot;.&quot;
                        and klatka[liczba_klatka][0] != &quot;.&quot;
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][8] != &quot;.&quot;
                        and klatka[liczba_klatka][7] != &quot;.&quot;
                        and (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom - 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z jedna cyfra-----------------------------------------------------------------

elif (
                        (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion + 1])
                        and klatka[liczba_klatka][8] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion + 2])
                        and klatka[liczba_klatka][7] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                        and (j in poziom[liczba_poziom - 1])
                        and klatka[liczba_klatka][0] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                        and (j in poziom[liczba_poziom - 2])
                        and klatka[liczba_klatka][3] != '.'
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in poziom[liczba_poziom - 2])
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z pięcioma cyframi-----------------------------------------------------------------
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in pion[liczba_pion + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z trzema cyframi -------------------------------------------------------------

elif (
                        klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                    
                    # warunek z ostatnia cyfra--------------------------------------------------------------
                    
                    #klatka
                    elif (
                        j not in klatka[liczba_klatka] 
                        and klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

#???????????????????????????????????????????????????????????????????????????????????????????
            # --------------------------------------------------------------------------------------------------

elif liczba_pion % 3 == 1:

if liczba_poziom % 3 == 0:

# warunek z dwiema cyframi-----------------------------------------------------------------

if (
                        klatka[liczba_klatka][4] != &quot;.&quot;
                        and klatka[liczba_klatka][7] != &quot;.&quot;
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][2] != &quot;.&quot;
                        and klatka[liczba_klatka][0] != &quot;.&quot;
                        and (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom + 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z jedna cyfra-----------------------------------------------------------------

elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion + 1])
                        and klatka[liczba_klatka][0] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion - 1])
                        and klatka[liczba_klatka][2] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                        and (j in poziom[liczba_poziom + 2])
                        and klatka[liczba_klatka][4] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                        and (j in poziom[liczba_poziom + 1])
                        and klatka[liczba_klatka][7] != '.'
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in poziom[liczba_poziom + 2])
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z pięcioma cyframi-----------------------------------------------------------------
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and (j in poziom[liczba_poziom + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                
                    # warunek z trzema cyframi -------------------------------------------------------------

elif (
                        klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z ostatnia cyfra--------------------------------------------------------------
                    
                    #klatka
                    elif (
                        j not in klatka[liczba_klatka] 
                        and klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

#???????????????????????????????????????????????????????????????????????????????????????????

elif liczba_poziom % 3 == 1:

# warunek z dwiema cyframi-----------------------------------------------------------------

if (
                        klatka[liczba_klatka][1] != &quot;.&quot;
                        and klatka[liczba_klatka][7] != &quot;.&quot;
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][5] != &quot;.&quot;
                        and klatka[liczba_klatka][3] != &quot;.&quot;
                        and (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom - 1])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z jedna cyfra-----------------------------------------------------------------

elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion - 1])
                        and klatka[liczba_klatka][5] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 1])
                        and klatka[liczba_klatka][3] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                        and (j in poziom[liczba_poziom + 1])
                        and klatka[liczba_klatka][1] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                        and (j in poziom[liczba_poziom - 1])
                        and klatka[liczba_klatka][7] != '.'
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                    elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    # warunek z pięcioma cyframi-----------------------------------------------------------------
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and (j in poziom[liczba_poziom + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                    
                    # warunek z trzema cyframi -------------------------------------------------------------

elif (
                        klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z ostatnia cyfra--------------------------------------------------------------
                    
                    #klatka
                    elif (
                        j not in klatka[liczba_klatka] 
                        and klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

#???????????????????????????????????????????????????????????????????????????????????????????

elif liczba_poziom % 3 == 2:
                    
                    # warunek z dwiema cyframi-----------------------------------------------------------------

if (
                        klatka[liczba_klatka][1] != &quot;.&quot;
                        and klatka[liczba_klatka][4] != &quot;.&quot;
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][8] != &quot;.&quot;
                        and klatka[liczba_klatka][6] != &quot;.&quot;
                        and (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom - 2])
                    ):

poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    # warunek z jedna cyfra-----------------------------------------------------------------

elif (
                        (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion - 1])
                        and klatka[liczba_klatka][8] != &quot;.&quot;
                    ):

poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion + 1])
                        and klatka[liczba_klatka][6] != &quot;.&quot;
                    ):

poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                        and (j in poziom[liczba_poziom - 1])
                        and klatka[liczba_klatka][1] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                    elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                        and (j in poziom[liczba_poziom - 2])
                        and klatka[liczba_klatka][4] != '.'
                    ):

poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                    ):

poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z pięcioma cyframi-----------------------------------------------------------------
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and (j in pion[liczba_pion + 1])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z trzema cyframi -------------------------------------------------------------

elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z ostatnia cyfra--------------------------------------------------------------
                    
                    #klatka
                    elif (
                        j not in klatka[liczba_klatka] 
                        and klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

#???????????????????????????????????????????????????????????????????????????????????????????

# ---------------------------------------------------------------------------------------------------

elif liczba_pion % 3 == 2:

if liczba_poziom % 3 == 0:
                    
                    # warunek z dwiema cyframi-----------------------------------------------------------------

if (
                        klatka[liczba_klatka][5] != &quot;.&quot;
                        and klatka[liczba_klatka][8] != &quot;.&quot;
                        and (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][0] != &quot;.&quot;
                        and klatka[liczba_klatka][1] != &quot;.&quot;
                        and (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom + 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z jedna cyfra-----------------------------------------------------------------

elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion - 1])
                        and klatka[liczba_klatka][0] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion - 2])
                        and klatka[liczba_klatka][1] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                        and (j in poziom[liczba_poziom + 1])
                        and klatka[liczba_klatka][8] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                        and (j in poziom[liczba_poziom + 2])
                        and klatka[liczba_klatka][5] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z pięcioma cyframi-----------------------------------------------------------------
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in pion[liczba_pion - 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and (j in poziom[liczba_poziom + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z trzema cyframi -------------------------------------------------------------

elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion - 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion - 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z ostatnia cyfra--------------------------------------------------------------
                    
                    #klatka
                    elif (
                        j not in klatka[liczba_klatka] 
                        and klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                    
                #???????????????????????????????????????????????????????????????????????????????????????????

elif liczba_poziom % 3 == 1:

# warunek z dwiema cyframi-----------------------------------------------------------------

if (
                        klatka[liczba_klatka][2] != &quot;.&quot;
                        and klatka[liczba_klatka][8] != &quot;.&quot;
                        and (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                    ):
                        print('1',i)
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][4] != &quot;.&quot;
                        and klatka[liczba_klatka][3] != &quot;.&quot;
                        and (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom + 1])
                    ):
                        print('2',i)

poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                    
                    # warunek z jedna cyfra-----------------------------------------------------------------

elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion - 1])
                        and klatka[liczba_klatka][3] != &quot;.&quot;
                    ):
                        print('3',i)

poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion - 2])
                        and klatka[liczba_klatka][4] != &quot;.&quot;
                    ):
                        print('4',i)

poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                        and (j in poziom[liczba_poziom + 1])
                        and klatka[liczba_klatka][2] != &quot;.&quot;
                    ):
                        print('5',i)

poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                    elif (
                        (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                        and (j in poziom[liczba_poziom - 1])
                        and klatka[liczba_klatka][8] != '.'
                    ):
                        print('6',i)

poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                    ):
                        print('7',i)

poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z pięcioma cyframi-----------------------------------------------------------------
                   
                    elif (
                        klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and (j in pion[liczba_pion - 1])
                    ):
                        print('8',i)
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in pion[liczba_pion - 2])
                    ):
                        print('9',i)
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and (j in poziom[liczba_poziom + 1])
                    ):
                        print('10',i)
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 1])
                    ):
                        print('11',i)
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z trzema cyframi -------------------------------------------------------------

elif (
                        klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion - 2])
                    ):
                        print('12',i)
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion - 2])
                    ):
                        print('13',i)
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        print('14',i)
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        print('15',i)
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z ostatnia cyfra--------------------------------------------------------------
                    
                    
                #???????????????????????????????????????????????????????????????????????????????????????????

elif liczba_poziom % 3 == 2:
                    # warunek z dwiema cyframi-----------------------------------------------------------------

if (
                        klatka[liczba_klatka][2] != &quot;.&quot;
                        and klatka[liczba_klatka][5] != &quot;.&quot;
                        and (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][6] != &quot;.&quot;
                        and klatka[liczba_klatka][7] != &quot;.&quot;
                        and (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom - 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z jedna cyfra-----------------------------------------------------------------

elif (
                        (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion - 1])
                        and klatka[liczba_klatka][6] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion - 2])
                        and klatka[liczba_klatka][7] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                        and (j in poziom[liczba_poziom - 1])
                        and klatka[liczba_klatka][2] != &quot;.&quot;
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                        and (j in poziom[liczba_poziom - 2])
                        and klatka[liczba_klatka][5] != '.'
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        (j in poziom[liczba_poziom - 2])
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z pięcioma cyframi-----------------------------------------------------------------
                   
                    elif (
                        klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in pion[liczba_pion - 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom - 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

# warunek z trzema cyframi -------------------------------------------------------------

elif (
                        klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion - 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion - 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                    
                    # warunek z ostatnia cyfra--------------------------------------------------------------
                    #klatka
                    elif (
                        j not in klatka[liczba_klatka] 
                        and klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

#???????????????????????????????????????????????????????????????????????????????????????????

for z in poziom:
    print(z)

Private - Private paste aren't shown in recent listings.

Delete After - When should we delete your paste?

Spam protection -

Reply to "Untitled"