Encuentra el vértice diagonalmente opuesto al vértice M de un polígono de N lados

Dados dos enteros N y M , la tarea es encontrar el vértice diagonalmente opuesto al M ^-ésimo vértice de un polígono de N lados .

Ejemplos:

Entrada: N = 6, M = 2 
Salida: 5 
Explicación:

Se puede observar en la imagen de arriba que el vértice opuesto al vértice 5 es 2.

Entrada: N = 8, M = 5 
Salida: 1 
Explicación:

Se puede observar en la imagen de arriba que el vértice opuesto al vértice 8 es 1.

Enfoque: Los siguientes dos casos deben ser considerados para resolver el problema dado:

1. Si M > N/2: El vértice siempre será M — (N/2) .
2. Si M ≤ N/2: El vértice siempre será M + (N/2) .

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

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the
// required vertex
int getPosition(int N, int M)
{
 
    // Case 1:
    if (M > (N / 2)) {
        return (M - (N / 2));
    }
 
    // Case 2:
    return (M + (N / 2));
}
 
// Driver Code
int main()
{
    int N = 8, M = 5;
    cout << getPosition(N, M);
 
    return 0;
}

// Java program for
// the above approach
class GFG{
 
// Function to return the
// required vertex
static int getPosition(int N,
                       int M)
{
  // Case 1:
  if (M > (N / 2))
  {
    return (M - (N / 2));
  }
 
  // Case 2:
  return (M + (N / 2));
}
 
// Driver Code
public static void main(String[] args)
{
  int N = 8, M = 5;
  System.out.print(getPosition(N, M));
 
}
}
 
// This code is contributed by Rajput-Ji

# Python3 program for the
# above approach
 
# Function to return the
# required vertex
def getPosition(N, M):
     
  # Case 1:
  if (M > (N // 2)):
    return (M - (N // 2))
    
  # Case 2:
  return (M + (N // 2))
   
# Driver Code
N = 8
M = 5
 
print(getPosition(N, M))
 
# This code is contributed by code_hunt

// C# program for the above approach
using System;
 
class GFG{
 
// Function to return the
// required vertex
static int getPosition(int N, int M)
{
     
    // Case 1:
    if (M > (N / 2))
    {
        return (M - (N / 2));
    }
     
    // Case 2:
    return (M + (N / 2));
}
 
// Driver Code
public static void Main(String[] args)
{
    int N = 8, M = 5;
     
    Console.Write(getPosition(N, M));
}
}
 
// This code is contributed by Amit Katiyar

<script>
 
 
// Javascript program for the above approach
 
// Function to return the
// required vertex
function getPosition(N, M)
{
 
    // Case 1:
    if (M > parseInt(N / 2)) {
        return (M - parseInt(N / 2));
    }
 
    // Case 2:
    return (M + parseInt(N / 2));
}
 
// Driver Code
var N = 8, M = 5;
document.write(getPosition(N, M));
 
</script>

1

Tiempo Complejidad: O(1)
Espacio Auxiliar: O(1)