Encuentre el elemento en el índice especificado en una array espiral

Dados dos enteros i y j , la tarea es imprimir los i * j ^-ésimos elementos de la array que se pueden obtener llenando la array de la siguiente manera en espiral:

Representación de cuadrícula en espiral fig 1

Ejemplos:

Entrada: i = 3, j = 4
Salida: 12
Explicación:
i = 3, j = 4 y grid[3][4] = 12

Entrada: i = 5, j = 5
Salida: 21
Explicación:
i = 5, j = 5 grid[5][5] = 21

Planteamiento: En el problema se puede observar que cuando i es par el primer número de la cuadrícula es i ² (2 ²  = 4 en 2da fila), y cuando i es el primer número impar de la cuadrícula es  (i-1 ) ² + 1 ((3-1) ² + 1 = 5 en la 3ra fila). De manera similar, cuando j es impar, el primer número de la cuadrícula es  j ² (3 ² = 9 en la 3.ª columna) y cuando j es par, el primer número de la cuadrícula es  (j-1) ² + 1 ((4-1) ² + 1 = 10 en la 4ª columna). Entonces, cada fila comienza con  i ²o  (i-1) ² + 1 y cada columna comienza con  j ²  o  (j-1) ² + 1 . 

El problema se puede dividir en los siguientes casos: 

• Caso 1: i = j 
  Observe que los elementos diagonales de la cuadrícula se pueden representar mediante la fórmula  i ² – (i-1) o j ² – (j – 1) .
• Caso 2: i > j
  • Caso 1: i es par
    En este caso, el primer número de la fila i será  i ² . Ahora, restando  (j – 1) del primer número de la fila, calcule el valor presente en el índice dado. Entonces la fórmula será  i ²  – (j-1) .
  • Caso 2: i es impar 
    En este caso, el primer número de la fila i será  (i – 1) ² + 1 . Ahora, sumando  (j – 1) al primer número de la fila, calcule el valor presente en el índice dado. Entonces la fórmula será  (i – 1) ² + 1 + (j – 1) .
• Caso 3: yo < j
  • Caso 1: j es par
    En este caso, el primer número de la columna j será (j – 1) ² + 1 . Ahora, sumando  (i – 1) al primer número de la columna, calcule el valor presente en el índice dado. Entonces la fórmula será  (j – 1) ² + 1 + (i – 1) .
  • Caso 2: j es impar
    En este caso, el primer número de la columna j será j ² . Ahora, restando  (i – 1) del primer número de la columna, calcule el valor presente en el índice dado. Entonces la fórmula será  j ² + 1 – (i – 1) .

Siga los pasos a continuación para resolver el problema:

1. Compruebe si i es igual a j e imprima i * i – (i – 1) .
2. Si i es mayor que j :
   1. Si i es par imprima  i * i – (j – 1) .
   2. De lo contrario, imprime ( i – 1)* (i – 1) + 1 + (j – 1) .
3. Si j es mayor que  i :
   1. Si j es par imprimir  (j – 1) * (j – 1) + 1 + (i – 1) .
   2. De lo contrario, imprima  j * j – (i – 1) .

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

// C++ program for the above approach
#include <iostream>
using namespace std;
 
// Function to the find
// element at (i, j) index
int findInGrid(int i, int j)
{
    if (i == j)
        return (i * i - (i - 1));
 
    else if (i > j) {
        if (i % 2 == 0)
            return i * i - (j - 1);
        else
            return (i - 1) * (i - 1) + 1 + (j - 1);
    }
 
    else {
        if (j % 2 == 0)
            return (j - 1) * (j - 1) + 1 + (i - 1);
        else
            return j * j - (i - 1);
    }
}
 
// Driver Code
int main()
{
 
    int i = 3, j = 4;
 
    // Function Call
    cout << findInGrid(i, j);
 
    return 0;
}

// Java program for the above approach
import java.io.*;
 
class GFG{
 
// Function to the find
// element at (i, j) index
static int findInGrid(int i, int j)
{
    if (i == j)
        return (i * i - (i - 1));
 
    else if (i > j)
    {
        if (i % 2 == 0)
            return i * i - (j - 1);
        else
            return (i - 1) * (i - 1) +
                         1 + (j - 1);
    }
 
    else
    {
        if (j % 2 == 0)
            return (j - 1) * (j - 1) +
                         1 + (i - 1);
        else
            return j * j - (i - 1);
    }
}
 
// Driver Code
public static void main(String[] args)
{
    int i = 3, j = 4;
 
    // Function Call
    System.out.println(findInGrid(i, j));
}
}
 
// This code is contributed by Dharanendra L V

# Python3 program for the above approach
 
# Function to the find
# element at(i, j) index
def findInGrid(i, j):
     
    if (i == j):
        return (i * i - (i - 1))
 
    elif (i > j):
        if (i % 2 == 0):
            return i * i - (j - 1)
        else :
            return ((i - 1) * (i - 1) +
                          1 + (j - 1))
 
    else:
        if (j % 2 == 0):
            return ((j - 1) * (j - 1) +
                          1 + (i - 1))
        else:
            return j * j - (i - 1)
 
# Driver Code
i = 3
j = 4
 
# Function Call
print(findInGrid(i, j))
 
# This code is contributed by Dharanendra L V

// C# program for the above approach
using System;
 
class GFG{
 
// Function to the find
// element at (i, j) index
static int findInGrid(int i, int j)
{
    if (i == j)
        return (i * i - (i - 1));
 
    else if (i > j)
    {
        if (i % 2 == 0)
            return i * i - (j - 1);
        else
            return (i - 1) * (i - 1) +
                         1 + (j - 1);
    }
 
    else
    {
        if (j % 2 == 0)
            return (j - 1) * (j - 1) +
                         1 + (i - 1);
        else
            return j * j - (i - 1);
    }
}
 
// Driver Code
static public void Main()
{
    int i = 3, j = 4;
     
    // Function Call
    Console.WriteLine(findInGrid(i, j));
}
}
 
// This code is contributed by Dharanendra L V

<script>
 
// Javascript program for the above approach
 
// Function to the find
// element at (i, j) index
function findInGrid(i, j)
{
    if (i == j)
        return (i * i - (i - 1));
 
    else if (i > j) {
        if (i % 2 == 0)
            return i * i - (j - 1);
        else
            return (i - 1) * (i - 1) + 1 + (j - 1);
    }
 
    else {
        if (j % 2 == 0)
            return (j - 1) * (j - 1) + 1 + (i - 1);
        else
            return j * j - (i - 1);
    }
}
 
// Driver Code
 
    let i = 3, j = 4;
 
    // Function Call
    document.write(findInGrid(i, j));
     
</script>

12

Complejidad temporal: O(1)
Espacio auxiliar: O(1)