Recuento de filas palindrómicas en Matrix dada

Dada una array arr[][] de tamaño N * N, la tarea es encontrar el número de filas palindrómicas .

Ejemplos :

Entrada : arr[][] = {{1, 3, 1},  
                         {2, 2, 3},  
                         {2, 1, 2}} 
Salida : 2
Explicación : la primera y la tercera fila forman un palíndromo, es decir, 1 3 1 y 2 1 2. 
Por lo tanto, el recuento de filas palindrómicas es 2.

Entrada : arr[][] = {{2, 2, 3, 2},  
                         {1, 3, 3, 1},  
                         {4, 2, 2, 4},  
                         {5, 6, 6, 5}}  
Salida : 3

Enfoque : la tarea se puede resolver utilizando un enfoque de dos puntos . Siga los pasos que se mencionan a continuación:

• Iterar sobre cada fila de la array.
• Por cada fila:
  • Use dos punteros para señalar el comienzo de la fila y el final de la fila.
  • Si los valores de ambos punteros son iguales, aumente el puntero inicial y disminuya el puntero final.
  • Continúe haciendo esto hasta que ambos punteros apunten al mismo elemento o tengan valores diferentes.
  • Si tienen valores diferentes la fila no es un palíndromo. Detenga la iteración y devuelva falso. De lo contrario, continúe para la siguiente fila.
• Después de recorrer todas las filas y que todos sean palíndromos, devuelva verdadero.

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

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100;
 
// Function to count the number of
// palindromic rows
int countPalindrome(
    vector<vector<int> >& arr,
    int N)
{
    int count = 0;
    for (int i = 0; i < N; i++) {
        int j = 0, k = N - 1;
        bool t = true;
        while (j < k) {
            if (arr[i][j] != arr[i][k]) {
                t = false;
                break;
            }
            j++;
            k--;
        }
        if (t)
            count++;
    }
    return count;
}
 
// Driver Code
int main()
{
    int N = 3;
    vector<vector<int> > arr
        = { { 1, 3, 1 }, { 2, 2, 3 }, { 2, 1, 2 } };
    cout << countPalindrome(arr, N);
    return 0;
}

// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
class Solution {
    // Function to count the number of
    // palindromic rows
    static int countPalindrome(int arr[][],
                               int N)
    {
        int count = 0;
        for (int i = 0; i < N; i++) {
            int j = 0, k = N - 1;
            boolean t = true;
            while (j < k) {
                if (arr[i][j] != arr[i][k]) {
                    t = false;
                    break;
                }
                j++;
                k--;
            }
            if (t)
                count++;
        }
        return count;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int N = 3;
        int arr[][]
            = { { 1, 3, 1 }, { 2, 2, 3 }, { 2, 1, 2 } };
        System.out.println(
            countPalindrome(arr, N));
    }
}

# Python program for the above approach
MAX = 100;
 
# Function to count the number of
# palindromic rows
def countPalindrome(arr, N):
    count = 0;
    for i in range(N):
        j = 0
        k = N - 1
        t = True
        while (j < k):
            if (arr[i][j] != arr[i][k]):
                t = False
                break;
            j += 1
            k -= 1
        if (t):
            count += 1
    return count;
 
# Driver Code
N = 3;
arr = [[1, 3, 1], [2, 2, 3], [2, 1, 2]];
print(countPalindrome(arr, N));
 
# This code is contributed by gfgking

// C# program for the above approach
using System;
 
public class GFG{
 
  // Function to count the number of
  // palindromic rows
  static int countPalindrome(int[,] arr,
                             int N)
  {
    int count = 0;
    for (int i = 0; i < N; i++) {
      int j = 0, k = N - 1;
      bool t = true;
      while (j < k) {
        if (arr[i, j] != arr[i, k]) {
          t = false;
          break;
        }
        j++;
        k--;
      }
      if (t)
        count++;
    }
    return count;
  }
 
  // Driver code
  static public void Main (){
 
    int N = 3;
    int[,] arr = new int[3, 3] { { 1, 3, 1 }, { 2, 2, 3 }, { 2, 1, 2 } };
    Console.WriteLine(
      countPalindrome(arr, N));
  }
}
 
// This code is contributed by hrithikgarg03188.

<script>
    // JavaScript program for the above approach
    const MAX = 100;
 
    // Function to count the number of
    // palindromic rows
    const countPalindrome = (arr, N) => {
        let count = 0;
        for (let i = 0; i < N; i++) {
            let j = 0, k = N - 1;
            let t = true;
            while (j < k) {
                if (arr[i][j] != arr[i][k]) {
                    t = false;
                    break;
                }
                j++;
                k--;
            }
            if (t)
                count++;
        }
        return count;
    }
 
    // Driver Code
    let N = 3;
    let arr = [[1, 3, 1], [2, 2, 3], [2, 1, 2]];
    document.write(countPalindrome(arr, N));
 
// This code is contributed by rakeshsahni
 
</script>

2

Complejidad de tiempo : O(N*N)
Espacio auxiliar : O(1)