Comprueba si una torre puede llegar al destino dado en un solo movimiento

Dados los enteros fila_actual y columna_actual , que representan la posición actual de una torre en un tablero de ajedrez de 8 × 8 y dos enteros más fila_destino y columna_destino que representan la posición que alcanzará una torre. La tarea es verificar si es posible o no que una Torre alcance el destino dado en un solo movimiento desde su posición actual. Si se encuentra que es cierto, escriba “POSIBLE” . De lo contrario, escriba «NO POSIBLE» .

Ejemplos:

Entrada: fila_actual=8, columna_actual=8, fila_destino=8, columna_destino=4 
Salida: POSIBLE
Explicación: 
 

Posible

Entrada: fila_actual=3, columna_actual=2, fila_destino=2, columna_destino=4 
Salida: NO ES POSIBLE 
Explicación: 
 

Imposible

 

 

Enfoque: El problema dado se puede resolver usando la siguiente observación:

En un tablero de ajedrez, una torre puede moverse tantos cuadrados como sea posible, tanto horizontal como verticalmente, en un solo movimiento. Por lo tanto, puede moverse a cualquier posición presente en la misma fila o columna que en su posición inicial.

Por lo tanto, el problema se reduce a simplemente verificar las siguientes dos condiciones: 
 

• Si fila_destino y fila_actual son iguales o no.
• De lo contrario, verifique si Destination_col es igual a current_col o no.
• Si se cumple alguna de las dos condiciones anteriores, escriba “ POSIBLE ”. De lo contrario, escriba «NO POSIBLE» .

A continuación se muestra la implementación del enfoque anterior:

// C++ program to implement
// for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if it is
// possible to reach destination
// in a single move by a rook
string check(int current_row, int current_col,
             int destination_row, int destination_col)
{
 
    if(current_row == destination_row)
        return "POSSIBLE";
    else if(current_col == destination_col)
        return "POSSIBLE";
    else
        return "NOT POSSIBLE";
}
 
// Driver Code
int main()
{
   
  // Given arrays
  int current_row = 8;
  int current_col = 8;
  int destination_row = 8;
  int destination_col = 4;
  string output = check(current_row, current_col,
                        destination_row, destination_col);
  cout << output;
  return 0;
}
 
// This code is contributed by mohit kumar 29.

// Java program for the above approach
import java.util.*;
import java.lang.*;
 
class GFG{
     
// Function to check if it is
// possible to reach destination
// in a single move by a rook
static String check(int current_row, int current_col,
             int destination_row, int destination_col)
{
 
    if(current_row == destination_row)
        return "POSSIBLE";
    else if(current_col == destination_col)
        return "POSSIBLE";
    else
        return "NOT POSSIBLE";
}
 
// Driver code
public static void main(String[] args)
{
    // Given arrays
  int current_row = 8;
  int current_col = 8;
  int destination_row = 8;
  int destination_col = 4;
  String output = check(current_row, current_col,
                        destination_row, destination_col);
  System.out.println(output);
}
}
 
// This code is contributed by code_hunt.

# Python program to implement
# for the above approach
 
 
# Function to check if it is
# possible to reach destination
# in a single move by a rook
def check(current_row, current_col,
           destination_row, destination_col):
     
    if(current_row == destination_row):
        return("POSSIBLE")
    elif(current_col == destination_col):
        return("POSSIBLE")
    else:
        return("NOT POSSIBLE")
 
# Driver Code
current_row = 8
current_col = 8
destination_row = 8
destination_col = 4
 
 
output = check(current_row, current_col,
               destination_row, destination_col)
print(output)

// C# program to implement
// the above approach
using System;
 
class GFG
{
 
  // Function to check if it is
  // possible to reach destination
  // in a single move by a rook
  static string check(int current_row, int current_col,
                      int destination_row, int destination_col)
  {
 
    if(current_row == destination_row)
      return "POSSIBLE";
    else if(current_col == destination_col)
      return "POSSIBLE";
    else
      return "NOT POSSIBLE";
  }
 
  // Driver Code
  public static void  Main()
  {
    // Given arrays
    int current_row = 8;
    int current_col = 8;
    int destination_row = 8;
    int destination_col = 4;
    string output = check(current_row, current_col,
                          destination_row, destination_col);
    Console.WriteLine(output);
  }
}
 
// This code is contributed by susmitakundugoaldanga.

<script>
// javascript program of the above approach
 
// Function to check if it is
// possible to reach destination
// in a single move by a rook
function check(current_row, current_col,
             destination_row, destination_col)
{
 
    if(current_row == destination_row)
        return "POSSIBLE";
    else if(current_col == destination_col)
        return "POSSIBLE";
    else
        return "NOT POSSIBLE";
}
 
    // Driver Code
     
   // Given arrays
  let current_row = 8;
  let current_col = 8;
  let destination_row = 8;
  let destination_col = 4;
  let output = check(current_row, current_col,
                        destination_row, destination_col);
  document.write(output);
 
</script>

POSSIBLE

Complejidad temporal: O(1) 
Complejidad espacial : O(1)