Editing 3430 - Bpj 2020

Gigel a descoperit noul joc Block Puzzle Jewel. Jocul se desfășoară astfel:

* avem o tablă de joc sub forma unei matrice <code>8x8</code>;
* sunt <code>17</code> tipuri de piese care arată așa:
* după ce Gigel adaugă o piesa, pătrățelele din care este formată piesa vor ocupa zonele corespunzătoare din tabla de joc iar, iar numărul de pătrățele din care este formată piesa se va adăuga la scorul lui Gigel. De exemplu,  dacă Gigel vrea să mute o piesă de tipul <code>16</code> atunci ea va ocupa locurile <code>m[i][j]</code> , <code>m[i][j+1]</code> , <code>m[i][j+2]</code> , <code>m[i+1][j+2]</code> și <code>m[i+2][j+2]</code> iar scorul lui Gigel va crește cu <code>5</code> puncte sau dacă Gigel vrea să mute o piesă de tipul <code>15</code> atunci ea va ocupa locurile <code>m[i][j] , m[i][j+1] , m[i+1][j-1]</code>  și <code>m[i+1][j]</code> iar scorul lui Gigel va crește cu <code>4</code> puncte.
* dacă o linie sau o coloana este completată cu pătratele atunci ea se eliberează (se elimină pătrățelele care ocupă linia/coloana).
* modul de a pozitiona o piesă este așa : <code>a l c</code>, unde <code>a</code> este tipul piesei, <code>l</code> și <code>c</code> reprezintă linia și coloana unde se va afla pătrățelul din stânga sus al piesei respective în matrice
* Dacă la o mutare se elimină:
** o linie sau o coloană , atunci Gigel primeste <code>10</code> puncte
** <code>2</code> linii și coloane liberate, atunci Gigel primește <code>30</code> de puncte
** <code>3</code> linii și coloane eliberate, atunci Gigel primește <code>60</code> de puncte
** <code>4</code> linii și coloane eliberate, atunci Gigel primește <code>100</code> de puncte
** <code>5</code> linii și coloane eliberate, atunci Gigel primește <code>150</code> de puncte
** <code>6</code> linii și coloane eliberate, atunci Gigel primește <code>500</code> de puncte

Dându-se <code>n</code>, numărul de piese pe care le va muta Gigel și piesele pe care le va muta Gigel (folosind numerele <code>a</code>, <code>l</code> și <code>c</code>), să se determine scorul final al lui Gigel.

= Date de intrare =
Fișierul de intrare <code>bpj2020.in</code> conține pe prima linie numărul <code>n</code>, iar pe următoarele <code>n</code> linii câte <code>3</code> numere <code>a l c</code> cu semnificația din enunț.

= Date de ieșire =
Fișierul de ieșire <code>bpj2020.out</code> va conține pe prima linie numărul <code>S</code>, reprezentând scorul final al lui Gigel.

= Restricții și precizări =

* <code>1 ≤ n ≤ 50</code>
* <code>1 ≤ l , c ≤ 8</code>
* <code>1 ≤ a ≤ 17</code>
* nu o să existe o piesa suprapusă peste alta și nici piese care să iasă din tabla de joc
* la început tabla de joc este goală

= Exemplu =
<code>bpj2020.in</code>
 9
 17 7 1
 5 8 4
 3 7 2
 10 5 5
 12 4 4
 1 6 4
 7 4 1
 6 5 6
 16 4 6
<code>bpj2020.out</code>
 108
<syntaxhighlight lang="python" line="1">
# Definirea pieselor și pozițiilor lor relative
pieces = {
    1:  [(0, 0)],
    2:  [(0, 0), (0, 1)],
    3:  [(0, 0), (1, 0)],
    4:  [(0, 0), (0, 1), (1, 0)],
    5:  [(0, 0), (0, 1), (0, 2)],
    6:  [(0, 0), (1, 0), (2, 0)],
    7:  [(0, 0), (0, 1), (1, 1)],
    8:  [(0, 0), (1, 0), (1, 1)],
    9:  [(0, 0), (0, 1), (1, 0), (1, 1)],
    10: [(0, 0), (0, 1), (0, 2), (1, 0)],
    11: [(0, 0), (0, 1), (0, 2), (1, 2)],
    12: [(0, 0), (1, 0), (1, 1), (1, 2)],
    13: [(0, 0), (1, 0), (2, 0), (2, 1)],
    14: [(0, 0), (1, 0), (2, 0), (2, -1)],
    15: [(0, 0), (0, 1), (1, -1), (1, 0)],
    16: [(0, 0), (0, 1), (0, 2), (1, 2), (2, 2)],
    17: [(0, 0), (1, 0), (2, 0), (2, 1), (2, 2)],
}

def check_and_clear(board, n):
    cleared_lines = 0
    rows_to_clear = [i for i in range(n) if all(board[i][j] for j in range(n))]
    cols_to_clear = [j for j in range(n) if all(board[i][j] for i in range(n))]

    for row in rows_to_clear:
        for j in range(n):
            board[row][j] = 0
        cleared_lines += 1

    for col in cols_to_clear:
        for i in range(n):
            board[i][col] = 0
        cleared_lines += 1

    score_bonus = [0, 10, 30, 60, 100, 150, 500]
    return cleared_lines, score_bonus[cleared_lines]

def play_game(n, moves):
    board = [[0] * 8 for _ in range(8)]
    score = 0

    for a, l, c in moves:
        for dx, dy in pieces[a]:
            x, y = l + dx - 1, c + dy - 1
            board[x][y] = 1
            score += 1

        cleared_lines, bonus = check_and_clear(board, 8)
        score += bonus

    return score

# Citirea inputului
n = int(input())
moves = [tuple(map(int, input().split())) for _ in range(n)]

# Calcularea scorului final
final_score = play_game(n, moves)
print(final_score)
</syntaxhighlight>