1221 - PieseSah - Revision history

RaulOtet: Pagină nouă: = Cerința = Se consideră o tablă de șah de dimensiune `n` (alcătuită din `n` linii si `n` coloane), pe care se află `m` piese de șah, fiecare putând fi: pion, rege, regină, nebun, tură sau cal). Se dau coordonatele a `t` căsuțe de pe tablă și se cere să se verifice pentru fiecare dacă este atacată, ocupată sau neatacată de piesele care se află pe tablă . = Date de intrare = Fișierul de intrare
2024-07-31T05:50:41Z

Pagină nouă: = Cerința = Se consideră o tablă de șah de dimensiune <code>n</code> (alcătuită din <code>n</code> linii si <code>n</code> coloane), pe care se află <code>m</code> piese de șah, fiecare putând fi: pion, rege, regină, nebun, tură sau cal). Se dau coordonatele a <code>t</code> căsuțe de pe tablă și se cere să se verifice pentru fiecare dacă este atacată, ocupată sau neatacată de piesele care se află pe tablă . = Date de intrare = Fișierul de intrare <cod...

New page
= Cerința =
Se consideră o tablă de șah de dimensiune <code>n</code> (alcătuită din <code>n</code> linii si <code>n</code> coloane), pe care se află <code>m</code> piese de șah, fiecare putând fi: pion, rege, regină, nebun, tură sau cal). Se dau coordonatele a <code>t</code> căsuțe de pe tablă și se cere să se verifice pentru fiecare dacă este atacată, ocupată sau neatacată de piesele care se află pe tablă .

= Date de intrare =
Fișierul de intrare <code>piesesah.in</code> conține pe prima linie trei numere <code>n m t</code>. Următoarele <code>m</code> linii conțin un caracter, literă mică (reprezentând tipul piesei) urmat de două numere naturale reprezentând coordonatele piesei. Următoarele <code>t</code> linii conțin câte două numere naturale reprezentând coordonatele unei căsuțe care trebuie verificată.

= Date de ieșire =
Fișierul de ieșire <code>piesesah.out</code> va conține pe <code>t</code> linii câte un singur număr natural <code>0</code> , <code>1</code> sau <code>2</code>, după cum căsuța corespunzătoare este neatacată, atacată sau ocupată.

= Restricții și precizări =

* <code>1 ≤ n ≤ 1000</code>
* <code>1 ≤ m < n * n</code>
* <code>1 ≤ t ≤ 50000</code>
* Nu vor exista două piese pe aceeași poziție;
* Caracterele care precizează piesele de pe tablă pot fi:
<code>p</code> – pion;
<code>r</code> – rege;
<code>q</code> – regină;
<code>n</code> – nebun;
<code>t</code> – tură;
<code>c</code> – cal;
* Piesele de pe tablă atacă astfel:
regele atacă oricare dintre cele <code>8</code> căsuțe vecine pe linie, coloană sau diagonale, situate pe tablă;
pionul atacă oricare dintre cele <code>4</code> căsuțe vecine pe diagonale, situate pe tablă;
calul atacă oricare dintre <code>8</code> căsuțe, situate pe tablă, în care poate ajunge sărind în <code>L</code>;
regina atacă orice căsuță de pe tablă aflată pe aceeași linie, coloană sau diagonală cu ea, dar până la întâlnirea altei piese;
nebunul atacă orice căsuță de pe tablă aflată pe aceeași diagonală cu el, dar până la întâlnirea altei piese;
tura atacă orice căsuță de pe tablă aflată pe aceeași linie sau coloană cu ea, dar până la întâlnirea altei piese;

= Exemplu =
<code>piesesah.in</code>
10 6 10
p 1 1
r 8 9
q 3 2
n 6 7
t 2 9
c 9 3
1 1
5 5
2 3
5 2
9 6
8 9
10 10
9 2
2 2
7 2
<code>piesesah.out</code>
2
0
1
1
0
2
0
1
1
1

=== Explicație ===
Tabla de șah arată astfel:
2 1 0 1 0 0 0 0 1 0
1 1 1 1 1 1 1 1 2 1
1 2 1 1 1 1 1 1 1 1
1 1 1 0 1 0 0 0 1 0
0 1 0 1 0 1 0 1 1 0
0 1 0 0 1 0 2 0 1 0
0 1 0 1 0 1 0 1 1 1
1 1 0 0 1 0 1 1 2 1
0 1 2 1 0 0 0 1 1 1
1 1 1 0 1 0 0 0 1 0
<syntaxhighlight lang="python" line="1">
def attack_positions_pawn(x, y, color, n):
attacks = []
if color == 'white':
if x > 0 and y > 0:
attacks.append((x - 1, y - 1))
if x > 0 and y < n - 1:
attacks.append((x - 1, y + 1))
else: # black
if x < n - 1 and y > 0:
attacks.append((x + 1, y - 1))
if x < n - 1 and y < n - 1:
attacks.append((x + 1, y + 1))
return attacks

def attack_positions_king(x, y, n):
attacks = []
for dx in range(-1, 2):
for dy in range(-1, 2):
if dx == 0 and dy == 0:
continue
if 0 <= x + dx < n and 0 <= y + dy < n:
attacks.append((x + dx, y + dy))
return attacks

def attack_positions_knight(x, y, n):
moves = [(2, 1), (1, 2), (-1, 2), (-2, 1), (-2, -1), (-1, -2), (1, -2), (2, -1)]
attacks = []
for dx, dy in moves:
if 0 <= x + dx < n and 0 <= y + dy < n:
attacks.append((x + dx, y + dy))
return attacks

def attack_positions_bishop(x, y, n):
attacks = []
for i in range(1, n):
if 0 <= x + i < n and 0 <= y + i < n:
attacks.append((x + i, y + i))
if 0 <= x - i < n and 0 <= y + i < n:
attacks.append((x - i, y + i))
if 0 <= x + i < n and 0 <= y - i < n:
attacks.append((x + i, y - i))
if 0 <= x - i < n and 0 <= y - i < n:
attacks.append((x - i, y - i))
return attacks

def attack_positions_rook(x, y, n):
attacks = []
for i in range(1, n):
if 0 <= x + i < n:
attacks.append((x + i, y))
if 0 <= x - i < n:
attacks.append((x - i, y))
if 0 <= y + i < n:
attacks.append((x, y + i))
if 0 <= y - i < n:
attacks.append((x, y - i))
return attacks

def attack_positions_queen(x, y, n):
return attack_positions_bishop(x, y, n) + attack_positions_rook(x, y, n)

def is_attacked(board, x, y):
return board[x][y] == 1

def main():
# Citirea dimensiunii tablei de șah
n = int(input().strip())

# Citirea numărului de piese
m = int(input().strip())

# Inițializarea tablei de șah
board = [[0] * n for _ in range(n)]

# Citirea pieselor și plasarea lor pe tabla de șah
for _ in range(m):
piece_info = input().strip().split()
piece_type = piece_info[0]
x = int(piece_info[1]) - 1 # Transformare la index 0
y = int(piece_info[2]) - 1 # Transformare la index 0
color = piece_info[3] if len(piece_info) > 3 else None # doar pentru pion

# Marcare poziție ocupată
board[x][y] = 2

# Obținerea pozițiilor atacate
if piece_type == "pion":
attacks = attack_positions_pawn(x, y, color, n)
elif piece_type == "rege":
attacks = attack_positions_king(x, y, n)
elif piece_type == "regina":
attacks = attack_positions_queen(x, y, n)
elif piece_type == "nebun":
attacks = attack_positions_bishop(x, y, n)
elif piece_type == "tura":
attacks = attack_positions_rook(x, y, n)
elif piece_type == "cal":
attacks = attack_positions_knight(x, y, n)

# Marcare poziții atacate
for ax, ay in attacks:
board[ax][ay] = max(board[ax][ay], 1)

# Citirea coordonatelor ce trebuiesc verificate
t = int(input().strip())
for _ in range(t):
x, y = map(int, input().strip().split())
x -= 1 # Transformare la index 0
y -= 1 # Transformare la index 0

if board[x][y] == 2:
print("ocupata")
elif board[x][y] == 1:
print("atacata")
else:
print("neatacata")

if name == "main":
main()
</syntaxhighlight>