es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

  • es.davy.ai/
  • Programación /
  • ¿Cómo puedo comprobar si el movimiento realizado por el Caballo y el Alfil es válido o no?

¿Cómo puedo comprobar si el movimiento realizado por el Caballo y el Alfil es válido o no?

16 Jun, 2023 Programación

Completar la siguiente función para validar el movimiento de una pieza de ajedrez dada y devolver Verdadero (booleano) si el movimiento es válido o Falso (booleano) si el movimiento es inválido. El tablero de ajedrez se proporciona a continuación para su referencia.

La función toma 3 argumentos:

pieza puede ser un “Caballo” o un “Alfil”

currentpos (una cadena) es una combinación de fila y columna y puede ser cualquier cosa entre “a1” y “h8”. currentpos representa la celda del tablero de ajedrez donde se encuentra actualmente la pieza

nextpos (una cadena) también es una combinación de fila y columna y también puede estar entre “a1” y “h8”. nextpos representa la celda a la que se pretende mover la pieza

Tenia dificultades para entender esta pregunta. ¿Alguien puede decirme cuál es el enfoque correcto para este problema?

def valid_movimiento_o_no(pieza, currentpos, nextpos):
    # Escriba su código aquí
    return True

if __name__ == '__main__':
    # puede ejecutar sus pruebas aquí
    print(valid_movimiento_o_no("Caballo", "a1", "a2"))
Tags:  , , , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Plan

    Para resolver este problema, primero necesitamos identificar los movimientos válidos que pueden realizar un caballo y un obispo:

    1. Caballo: Un caballo se mueve a cualquiera de las casillas inmediatamente adyacentes y luego se mueve dos casillas en dirección perpendicular. Por ejemplo, desde la casilla “a1”, un caballo puede moverse a las casillas “b3”, “c2” y “c4”.

    2. Obispo: Un obispo se mueve en diagonal cualquier número de casillas. Por ejemplo, desde la casilla “a1”, un obispo puede moverse a las casillas “b2”, “c3”, “d4”, etc.

    Podemos usar este conocimiento para escribir la función movimiento_valido_o_no. Aquí está cómo:

    1. Primero, debemos verificar si las posiciones actual y siguiente son casillas válidas en el tablero. Podemos hacer esto verificando si la fila y la columna están entre “a” y “h” inclusive y los números están entre 1 y 8 inclusive. Si alguno de ellos no es válido, devolvemos Falso.

  2. A continuación, verificamos qué pieza se está moviendo. Si es un caballo, verificamos si el movimiento es válido utilizando las reglas de movimiento del caballo. Si es un obispo, verificamos si el movimiento es válido utilizando las reglas de movimiento del obispo. Si la pieza no es ni un caballo ni un obispo, devolvemos Falso.

  3. Si el movimiento es válido, devolvemos Verdadero. De lo contrario, devolvemos Falso.

    4. Solución

    def movimiento_valido_o_no(pieza, pos_actual, pos_siguiente):
    # Verificar si las posiciones actual y siguiente son casillas válidas
    if pos_actual[0] not in "abcdefgh" or pos_actual[1] not in "12345678":
        return False
    if pos_siguiente[0] not in "abcdefgh" or pos_siguiente[1] not in "12345678":
        return False

    # Verificar qué pieza se está moviendo y validar según corresponda
    if pieza == "Caballo":
        # Calcular las diferencias absolutas entre fila y columna
        dr = abs(ord(pos_actual[0]) - ord(pos_siguiente[0]))
        dc = abs(int(pos_actual[1]) - int(pos_siguiente[1]))
        # Un movimiento de caballo es válido si las diferencias absolutas son (2, 1) o (1, 2)
        if (dr, dc) in [(2, 1), (1, 2)]:
            return True
    elif pieza == "Obispo":
        # Calcular las diferencias absolutas entre fila y columna
        dr = abs(ord(pos_actual[0]) - ord(pos_siguiente[0]))
        dc = abs(int(pos_actual[1]) - int(pos_siguiente[1]))
        # Un movimiento de obispo es válido si las diferencias absolutas de fila y columna son iguales
        if dr == dc:
            return True

    # Si el movimiento no es válido, devolver Falso
    return False

    Pruebas

    Probemos nuestra función con algunas entradas de muestra:

    if __name__ == '__main__':
    assert movimiento_valido_o_no("Caballo", "a1", "b3") == True
    assert movimiento_valido_o_no("Caballo", "a1", "c2") == True
    assert movimiento_valido_o_no("Caballo", "a1", "c4") == True
    assert movimiento_valido_o_no("Caballo", "a1", "b1") == False
    assert movimiento_valido_o_no("Caballo", "a1", "c3") == False
    assert movimiento_valido_o_no("Obispo", "a1", "b2") == True
    assert movimiento_valido_o_no("Obispo", "a1", "c3") == True
    assert movimiento_valido_o_no("Obispo", "a1", "d4") == True
    assert movimiento_valido_o_no("Obispo", "a1", "b1") == False
    assert movimiento_valido_o_no("Obispo", "a1", "c2") == False
    assert movimiento_valido_o_no("Caballo", "a1", "e5") == False

    Si no hay errores de afirmación, la función está funcionando correctamente.

Comments are closed.