कार्य«फ़र्ज़ी को उड़ाना»

💻 Python

आप एक ग्रैंडमास्टर हैं और आपको एक प्रोग्राम लिखना है जो मानक शतरंज बोर्ड 8 × 8 पर आठ फेरेज़ के निर्देशांक इनपुट पर प्राप्त करता है और उनकी व्यवस्था का पूर्ण विश्लेषण करता है।

इनपुट फॉर्मेट

आठ पंक्तियाँ, जिनमें से प्रत्येक में 1 से 8 तक के दो पूर्णांक हैं, जो एक अंतराल द्वारा अलग किए गए हैं & mdash; एक रानी के निर्देशांक (पहले पंक्ति संख्या, फिर स्तंभ संख्या)।

आउटपुट फॉर्मेट

परिदृश्य 1: हमला पाया गया।
यदि फ़र्ज़ियों का कम से कम एक जोड़ा एक-दूसरे पर हमला करता है, तो प्रोग्राम को:
1. शब्द yes प्रदर्शित करना चाहिए।
2. अगली पंक्ति में पहले हमला किए गए जोड़े के निर्देशांक और हमले के प्रकार को इंगित करें। उदाहरण के लिए: 1 1 और 8 8 एक-दूसरे पर विकर्ण रूप से हमला करते हैं।
3. उसके बाद, रखे गए फ़र्ज़ियों के साथ 8 × 8 का शतरंज बोर्ड बनाएं।
परिदृश्य 2: कोई हमला नहीं।
यदि कोई भी जोड़ा एक-दूसरे पर हमला नहीं करता (व्यवस्था सही है), तो प्रोग्राम को:
1. शब्द no प्रदर्शित करना चाहिए।
2. उसके बाद, रखे गए फ़र्ज़ियों के साथ 8 × 8 का शतरंज बोर्ड बनाएं।
बोर्ड विज़ुअलाइज़ेशन:
बोर्ड को 8x8 ग्रिड के रूप में प्रस्तुत किया जाना चाहिए। खाली कोशिकाओं को प्रतीक . द्वारा दर्शाया जाता है, और फ़र्ज़ी वाले कोशिकाओं को प्रतीक Q द्वारा दर्शाया जाता है।

उदाहरण

इनपुट

1 1
2 3
3 5
4 7
5 2
6 4
7 6
8 8

आउटपुट

हाँ
1 1 और 8 8 एक-दूसरे को विकर्ण रूप से हराते हैं।
Q. . . . . . .
. . Q. . . . .
. . . . Q. . .
. . . . . . Q.
. Q. . . . . .
. . . Q. . . .
. . . . . Q. .
. . . . . . . Q

संकेत

There will be no clue here, decide for yourself!

main.py

परीक्षण 1

परीक्षण 2

परीक्षण 3

परीक्षण 4

परीक्षण 5

परीक्षण 6

परीक्षण 7

परीक्षण 8

परीक्षण 9

परीक्षण 10

डेवलपर का समाधान

def read_and_validate_coordinates():
    """
    Считывает 8 пар координат, проверяет их на корректность.
    Возвращает список кортежей с координатами или None в случае ошибки.
    """
    coords = []
    try:
        for _ in range(8):
            # Считываем строку и разделяем на части
            parts = input().split()
            # Проверяем, что в строке ровно два элемента
            if len(parts) != 2:
                raise ValueError
            # Преобразуем в целые числа
            row, col = int(parts[0]), int(parts[1])
            # Проверяем, что координаты в диапазоне от 1 до 8
            if not (1 <= row <= 8 and 1 <= col <= 8):
                raise ValueError
            coords.append((row, col))
    except (ValueError, IndexError):
        # ValueError возникает при неудачном int() или если условия не выполнены
        # IndexError может возникнуть, если split() дал меньше 2 элементов (хотя len(parts) это покрывает)
        return None
    return coords

def find_attacking_pair(coords):
    """
    Ищет первую атакующую пару ферзей.
    Возвращает кортеж (queen1, queen2, attack_type) или None, если атак нет.
    """
    # Проверка на дубликаты координат (ферзи на одной клетке)
    if len(coords) != len(set(coords)):
        # Найдем первую дублирующуюся пару
        seen = set()
        duplicate = None
        for q in coords:
            if q in seen:
                duplicate = q
                break
            seen.add(q)
        
        # Найдем индексы дубликатов
        indices = [i for i, x in enumerate(coords) if x == duplicate]
        q1 = coords[indices[0]]
        q2 = coords[indices[1]]
        # Ферзи на одной клетке - это и горизонтальная, и вертикальная атака.
        # Выберем "вертикали" для определенности.
        return q1, q2, "вертикали"

    # Проверяем все уникальные пары ферзей
    for i in range(len(coords)):
        for j in range(i + 1, len(coords)):
            r1, c1 = coords[i]
            r2, c2 = coords[j]

            # Проверка по горизонтали
            if r1 == r2:
                return coords[i], coords[j], "горизонтали"
            
            # Проверка по вертикали
            if c1 == c2:
                return coords[i], coords[j], "вертикали"
            
            # Проверка по диагонали
            if abs(r1 - r2) == abs(c1 - c2):
                return coords[i], coords[j], "диагонали"
                
    return None, None, None

def print_board(coords):
    """
    Печатает шахматную доску 8x8 с расставленными ферзями.
    """
    board = [['.' for _ in range(8)] for _ in range(8)]
    for r, c in coords:
        # Координаты (1,1) соответствуют индексу [0][0]
        board[r - 1][c - 1] = 'Q'
    
    for row in board:
        print(' '.join(row))

def main():
    """
    Главная функция программы.
    """
    coordinates = read_and_validate_coordinates()
    
    if coordinates is None:
        print("Ошибка: координаты должны быть числами от 1 до 8.")
        return
        
    q1, q2, attack_type = find_attacking_pair(coordinates)
    
    if attack_type:
        print("YES")
        print(f"{q1[0]} {q1[1]} и {q2[0]} {q2[1]} бьют друг друга по {attack_type}.")
        print_board(coordinates)
    else:
        print("NO")


main()