Programa para Rango de Array

¿Qué es el rango de una array?  
El rango de una array A de tamaño M x N se define como 

  1. Número máximo de vectores columna linealmente independientes en la array o 
  2. Número máximo de vectores fila linealmente independientes en la array. 

Le recomendamos encarecidamente que haga clic aquí y lo practique antes de pasar a la solución.

Ejemplo:

Input:  mat[][] = {{10,   20,   10},
                   {20,   40,   20},
                   {30,   50,   0}}
Output: Rank is 2
Explanation: Ist and IInd rows are linearly dependent.
             But Ist and  3rd or IInd and IIIrd  are
             independent.   


Input:  mat[][] = {{10,   20,   10},
                   {-20, -30,   10},
                   {30,   50,   0}}
Output: Rank is 2
Explanation: Ist and IInd rows are linearly independent.
             So rank must be atleast 2. But all three rows
             are linearly dependent (the first is equal to
             the sum of the second and third) so the rank 
             must be less than 3. 

En otras palabras, el rango de A es el orden más grande de cualquier menor distinto de cero en A, donde el orden de un menor es la longitud del lado de la subarray cuadrada de la que es determinante.
Entonces, si M < N, el rango máximo de A puede ser M; de lo contrario, puede ser N, en general, el rango de la array no puede ser mayor que min (M, N).
El rango de una array sería cero solo si la array no tuviera elementos distintos de cero. Si una array tuviera incluso un elemento distinto de cero, su rango mínimo sería uno. 

¿Cómo encontrar el rango?  
La idea se basa en la conversión a la forma escalonada de filas

1) Let the input matrix be mat[][].  Initialize rank equals
   to number of columns

// Before we visit row 'row',  traversal of previous 
// rows make sure that mat[row][0],....mat[row][row-1]
// are 0.
2) Do following for row = 0 to rank-1.

  a) If mat[row][row] is not zero, make all elements of
     current column as 0 except the element mat[row][row]
     by finding appropriate multiplier and adding a the 
     multiple of row 'row'
        
  b) Else (mat[row][row] is zero). Two cases arise:
       (i) If there is a row below it with non-zero entry in 
           same column, then swap current 'row' and that row.
       (ii) If all elements in current column below mat[r][row] 
            are 0, then remove this column by swapping it with
            last column and  reducing number of rank by 1.
     Reduce row by 1 so that this row is processed again.

3) Number of remaining columns is rank of matrix.

Ejemplo: 

Input:  mat[][] = {{10,   20,   10},
                   {-20, -30,   10},
                   {30,   50,   0}}

row = 0:
Since mat[0][0] is not 0, we are in case 2.a of above algorithm.
We set all entries of 0'th column as 0 (except entry mat[0][0]).
To do this, we subtract R1*(-2) from R2, i.e., R2 --> R2 - R1*(-2)
         mat[][] = {{10,   20,   10},
                   { 0,    10,   30},
                    {30,   50,   0}}
            And subtract R1*3 from R3, i.e., R3   --> R3 - R1*3  
         mat[][] = {{10,   20,   10},
                    { 0,   10,   30},
                    { 0,  -10,  -30}}

row = 1:
Since mat[1][1] is not 0, we are in case 2.a of above algorithm.
We set all entries of 1st column as 0 (except entry mat[1][1]).
To do this, we subtract R2*2 from R1, i.e., R1 --> R1 - R2*2
         mat[][] = {{10,    0,  -50},
                    { 0,   10,   30},
                    { 0,  -10,  -30}}
           And subtract R2*(-1) from R3, i.e., R3   --> R3 - R2*(-1)
         mat[][] = {{10,   0,   -50},
                    { 0,   10,   30},
                    { 0,   0,     0}}

row = 2:
Since Since mat[2][2] is 0, we are in case 2.b of above algorithm.
Since there is no row below it swap. We reduce the rank by 1 and 
keep row as 2. 

The loop doesn't iterate next time because loop termination condition
row <= rank-1 returns false.

A continuación se muestra la implementación de la idea anterior.

C++

// C++ program to find rank of a matrix
#include <bits/stdc++.h>
using namespace std;
#define R 3
#define C 3
 
/* function for exchanging two rows of
   a matrix */
void swap(int mat[R][C], int row1, int row2,
          int col)
{
    for (int i = 0; i < col; i++)
    {
        int temp = mat[row1][i];
        mat[row1][i] = mat[row2][i];
        mat[row2][i] = temp;
    }
}
 
// Function to display a matrix
void display(int mat[R][C], int row, int col);
 
/* function for finding rank of matrix */
int rankOfMatrix(int mat[R][C])
{
    int rank = C;
 
    for (int row = 0; row < rank; row++)
    {
        // Before we visit current row 'row', we make
        // sure that mat[row][0],....mat[row][row-1]
        // are 0.
 
        // Diagonal element is not zero
        if (mat[row][row])
        {
           for (int col = 0; col < R; col++)
           {
               if (col != row)
               {
                 // This makes all entries of current
                 // column as 0 except entry 'mat[row][row]'
                 double mult = (double)mat[col][row] /
                                       mat[row][row];
                 for (int i = 0; i < rank; i++)
                   mat[col][i] -= mult * mat[row][i];
              }
           }
        }
 
        // Diagonal element is already zero. Two cases
        // arise:
        // 1) If there is a row below it with non-zero
        //    entry, then swap this row with that row
        //    and process that row
        // 2) If all elements in current column below
        //    mat[r][row] are 0, then remove this column
        //    by swapping it with last column and
        //    reducing number of columns by 1.
        else
        {
            bool reduce = true;
 
            /* Find the non-zero element in current
                column  */
            for (int i = row + 1; i < R;  i++)
            {
                // Swap the row with non-zero element
                // with this row.
                if (mat[i][row])
                {
                    swap(mat, row, i, rank);
                    reduce = false;
                    break ;
                }
            }
 
            // If we did not find any row with non-zero
            // element in current column, then all
            // values in this column are 0.
            if (reduce)
            {
                // Reduce number of columns
                rank--;
 
                // Copy the last column here
                for (int i = 0; i < R; i ++)
                    mat[i][row] = mat[i][rank];
            }
 
            // Process this row again
            row--;
        }
 
       // Uncomment these lines to see intermediate results
       // display(mat, R, C);
       // printf("\n");
    }
    return rank;
}
 
/* function for displaying the matrix */
void display(int mat[R][C], int row, int col)
{
    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < col; j++)
            printf("  %d", mat[i][j]);
        printf("\n");
    }
}
 
// Driver program to test above functions
int main()
{
   int mat[][3] = {{10,   20,   10},
                  {-20,  -30,   10},
                   {30,   50,   0}};
    printf("Rank of the matrix is : %d",
         rankOfMatrix(mat));
    return 0;
}

Java

// Java program to find rank of a matrix
class GFG {
     
    static final int R = 3;
    static final int C = 3;
     
    // function for exchanging two rows
    // of a matrix
    static void swap(int mat[][],
          int row1, int row2, int col)
    {
        for (int i = 0; i < col; i++)
        {
            int temp = mat[row1][i];
            mat[row1][i] = mat[row2][i];
            mat[row2][i] = temp;
        }
    }
     
    // Function to display a matrix
    static void display(int mat[][],
                     int row, int col)
    {
        for (int i = 0; i < row; i++)
        {
             
            for (int j = 0; j < col; j++)
             
                System.out.print(" "
                          + mat[i][j]);
                           
            System.out.print("\n");
        }
    }
     
    // function for finding rank of matrix
    static int rankOfMatrix(int mat[][])
    {
         
        int rank = C;
     
        for (int row = 0; row < rank; row++)
        {
             
            // Before we visit current row
            // 'row', we make sure that
            // mat[row][0],....mat[row][row-1]
            // are 0.
     
            // Diagonal element is not zero
            if (mat[row][row] != 0)
            {
                for (int col = 0; col < R; col++)
                {
                    if (col != row)
                    {
                        // This makes all entries
                        // of current column
                        // as 0 except entry
                        // 'mat[row][row]'
                        double mult =
                           (double)mat[col][row] /
                                    mat[row][row];
                                     
                        for (int i = 0; i < rank; i++)
                         
                            mat[col][i] -= mult
                                       * mat[row][i];
                    }
                }
            }
     
            // Diagonal element is already zero.
            // Two cases arise:
            // 1) If there is a row below it
            // with non-zero entry, then swap
            // this row with that row and process
            // that row
            // 2) If all elements in current
            // column below mat[r][row] are 0,
            // then remove this column by
            // swapping it with last column and
            // reducing number of columns by 1.
            else
            {
                boolean reduce = true;
     
                // Find the non-zero element
                // in current column
                for (int i = row + 1; i < R; i++)
                {
                    // Swap the row with non-zero
                    // element with this row.
                    if (mat[i][row] != 0)
                    {
                        swap(mat, row, i, rank);
                        reduce = false;
                        break ;
                    }
                }
     
                // If we did not find any row with
                // non-zero element in current
                // column, then all values in
                // this column are 0.
                if (reduce)
                {
                    // Reduce number of columns
                    rank--;
     
                    // Copy the last column here
                    for (int i = 0; i < R; i ++)
                        mat[i][row] = mat[i][rank];
                }
     
                // Process this row again
                row--;
            }
     
        // Uncomment these lines to see
        // intermediate results display(mat, R, C);
        // printf("\n");
        }
         
        return rank;
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int mat[][] = {{10, 20, 10},
                       {-20, -30, 10},
                       {30, 50, 0}};
                        
        System.out.print("Rank of the matrix is : "
                               + rankOfMatrix(mat));
    }
}
 
// This code is contributed by Anant Agarwal.

Python3

# Python 3 program to find rank of a matrix
class rankMatrix(object):
    def __init__(self, Matrix):
        self.R = len(Matrix)
        self.C = len(Matrix[0])
         
    # Function for exchanging two rows of a matrix
    def swap(self, Matrix, row1, row2, col):
        for i in range(col):
            temp = Matrix[row1][i]
            Matrix[row1][i] = Matrix[row2][i]
            Matrix[row2][i] = temp
             
    # Function to Display a matrix
    def Display(self, Matrix, row, col):
        for i in range(row):
            for j in range(col):
                print (" " + str(Matrix[i][j]))
            print ('\n')
             
    # Find rank of a matrix
    def rankOfMatrix(self, Matrix):
        rank = self.C
        for row in range(0, rank, 1):
             
            # Before we visit current row
            # 'row', we make sure that
            # mat[row][0],....mat[row][row-1]
            # are 0.
     
            # Diagonal element is not zero
            if Matrix[row][row] != 0:
                for col in range(0, self.R, 1):
                    if col != row:
                         
                        # This makes all entries of current
                        # column as 0 except entry 'mat[row][row]'
                        multiplier = (Matrix[col][row] /
                                      Matrix[row][row])
                        for i in range(rank):
                            Matrix[col][i] -= (multiplier *
                                               Matrix[row][i])
                                                 
            # Diagonal element is already zero.
            # Two cases arise:
            # 1) If there is a row below it
            # with non-zero entry, then swap
            # this row with that row and process
            # that row
            # 2) If all elements in current
            # column below mat[r][row] are 0,
            # then remove this column by
            # swapping it with last column and
            # reducing number of columns by 1.
            else:
                reduce = True
                 
                # Find the non-zero element
                # in current column
                for i in range(row + 1, self.R, 1):
                     
                    # Swap the row with non-zero
                    # element with this row.
                    if Matrix[i][row] != 0:
                        self.swap(Matrix, row, i, rank)
                        reduce = False
                        break
                         
                # If we did not find any row with
                # non-zero element in current
                # column, then all values in
                # this column are 0.
                if reduce:
                     
                    # Reduce number of columns
                    rank -= 1
                     
                    # copy the last column here
                    for i in range(0, self.R, 1):
                        Matrix[i][row] = Matrix[i][rank]
                         
                # process this row again
                row -= 1
                 
        # self.Display(Matrix, self.R,self.C)
        return (rank)
 
# Driver Code
if __name__ == '__main__':
    Matrix = [[10, 20, 10],
              [-20, -30, 10],
              [30, 50, 0]]
    RankMatrix = rankMatrix(Matrix)
    print ("Rank of the Matrix is:",
           (RankMatrix.rankOfMatrix(Matrix)))
 
# This code is contributed by Vikas Chitturi

C#

// C# program to find rank of a matrix
using System;
class GFG {
      
    static  int R = 3;
    static  int C = 3;
      
    // function for exchanging two rows
    // of a matrix
    static void swap(int [,]mat,
          int row1, int row2, int col)
    {
        for (int i = 0; i < col; i++)
        {
            int temp = mat[row1,i];
            mat[row1,i] = mat[row2,i];
            mat[row2,i] = temp;
        }
    }
      
    // Function to display a matrix
    static void display(int [,]mat,
                     int row, int col)
    {
        for (int i = 0; i < row; i++)
        {
              
            for (int j = 0; j < col; j++)
              
                Console.Write(" "
                          + mat[i,j]);
                            
            Console.Write("\n");
        }
    }
      
    // function for finding rank of matrix
    static int rankOfMatrix(int [,]mat)
    {
          
        int rank = C;
      
        for (int row = 0; row < rank; row++)
        {
              
            // Before we visit current row
            // 'row', we make sure that
            // mat[row][0],....mat[row][row-1]
            // are 0.
      
            // Diagonal element is not zero
            if (mat[row,row] != 0)
            {
                for (int col = 0; col < R; col++)
                {
                    if (col != row)
                    {
                        // This makes all entries
                        // of current column
                        // as 0 except entry
                        // 'mat[row][row]'
                        double mult =
                           (double)mat[col,row] /
                                    mat[row,row];
                                      
                        for (int i = 0; i < rank; i++)
                          
                            mat[col,i] -= (int) mult
                                     * mat[row,i];
                    }
                }
            }
      
            // Diagonal element is already zero.
            // Two cases arise:
            // 1) If there is a row below it
            // with non-zero entry, then swap
            // this row with that row and process
            // that row
            // 2) If all elements in current
            // column below mat[r][row] are 0,
            // then remove this column by
            // swapping it with last column and
            // reducing number of columns by 1.
            else
            {
                bool reduce = true;
      
                // Find the non-zero element
                // in current column
                for (int i = row + 1; i < R; i++)
                {
                    // Swap the row with non-zero
                    // element with this row.
                    if (mat[i,row] != 0)
                    {
                        swap(mat, row, i, rank);
                        reduce = false;
                        break ;
                    }
                }
      
                // If we did not find any row with
                // non-zero element in current
                // column, then all values in
                // this column are 0.
                if (reduce)
                {
                    // Reduce number of columns
                    rank--;
      
                    // Copy the last column here
                    for (int i = 0; i < R; i ++)
                        mat[i,row] = mat[i,rank];
                }
      
                // Process this row again
                row--;
            }
      
        // Uncomment these lines to see
        // intermediate results display(mat, R, C);
        // printf("\n");
        }
          
        return rank;
    }
      
    // Driver code
    public static void Main ()
    {
        int [,]mat = {{10, 20, 10},
                       {-20, -30, 10},
                       {30, 50, 0}};
                         
        Console.Write("Rank of the matrix is : "
                          + rankOfMatrix(mat));
    }
}
  
// This code is contributed by nitin mittal

PHP

<?php
// PHP program to find rank of a matrix
 
$R = 3;
$C = 3;
 
/* function for exchanging two rows of
a matrix */
function swap(&$mat, $row1, $row2, $col)
{
    for ($i = 0; $i < $col; $i++)
    {
        $temp = $mat[$row1][$i];
        $mat[$row1][$i] = $mat[$row2][$i];
        $mat[$row2][$i] = $temp;
    }
}
 
 
/* function for finding rank of matrix */
function rankOfMatrix($mat)
{
    global $R, $C;
    $rank = $C;
 
    for ($row = 0; $row < $rank; $row++)
    {
        // Before we visit current row 'row', we make
        // sure that mat[row][0],....mat[row][row-1]
        // are 0.
 
        // Diagonal element is not zero
        if ($mat[$row][$row])
        {
            for ($col = 0; $col < $R; $col++)
            {
                if ($col != $row)
                {
                    // This makes all entries of current
                    // column as 0 except entry 'mat[row][row]'
                    $mult = $mat[$col][$row] / $mat[$row][$row];
                    for ($i = 0; $i < $rank; $i++)
                        $mat[$col][$i] -= $mult * $mat[$row][$i];
                }
            }
        }
 
        // Diagonal element is already zero. Two cases
        // arise:
        // 1) If there is a row below it with non-zero
        // entry, then swap this row with that row
        // and process that row
        // 2) If all elements in current column below
        // mat[r][row] are 0, then remove this column
        // by swapping it with last column and
        // reducing number of columns by 1.
        else
        {
            $reduce = true;
 
            /* Find the non-zero element in current
                column */
            for ($i = $row + 1; $i < $R; $i++)
            {
                // Swap the row with non-zero element
                // with this row.
                if ($mat[$i][$row])
                {
                    swap($mat, $row, $i, $rank);
                    $reduce = false;
                    break ;
                }
            }
 
            // If we did not find any row with non-zero
            // element in current column, then all
            // values in this column are 0.
            if ($reduce)
            {
                // Reduce number of columns
                $rank--;
 
                // Copy the last column here
                for ($i = 0; $i < $R; $i++)
                    $mat[$i][$row] = $mat[$i][$rank];
            }
 
            // Process this row again
            $row--;
        }
 
    // Uncomment these lines to see intermediate results
    // display(mat, R, C);
    // printf("\n");
    }
    return $rank;
}
 
/* function for displaying the matrix */
function display($mat, $row, $col)
{
    for ($i = 0; $i < $row; $i++)
    {
        for ($j = 0; $j < $col; $j++)
            print(" $mat[$i][$j]");
        print("\n");
    }
}
 
// Driver code
$mat = array(array(10, 20, 10),
                array(-20, -30, 10),
                array(30, 50, 0));
print("Rank of the matrix is : ".rankOfMatrix($mat));
 
// This code is contributed by mits
?>

Javascript

<script>
 
// javascript program to find rank of a matrix
 
     
    var R = 3;
    var C = 3;
     
    // function for exchanging two rows
    // of a matrix
    function swap(mat, row1 , row2 , col)
    {
        for (i = 0; i < col; i++)
        {
            var temp = mat[row1][i];
            mat[row1][i] = mat[row2][i];
            mat[row2][i] = temp;
        }
    }
     
    // Function to display a matrix
    function display(mat,row , col)
    {
        for (i = 0; i < row; i++)
        {
             
            for (j = 0; j < col; j++)
             
                document.write(" "
                          + mat[i][j]);
                           
            document.write('<br>');
        }
    }
     
    // function for finding rank of matrix
    function rankOfMatrix(mat)
    {
         
        var rank = C;
     
        for (row = 0; row < rank; row++)
        {
             
            // Before we visit current row
            // 'row', we make sure that
            // mat[row][0],....mat[row][row-1]
            // are 0.
     
            // Diagonal element is not zero
            if (mat[row][row] != 0)
            {
                for (col = 0; col < R; col++)
                {
                    if (col != row)
                    {
                        // This makes all entries
                        // of current column
                        // as 0 except entry
                        // 'mat[row][row]'
                        var mult =
                           mat[col][row] /
                                    mat[row][row];
                                     
                        for (i = 0; i < rank; i++)
                         
                            mat[col][i] -= mult
                                       * mat[row][i];
                    }
                }
            }
     
            // Diagonal element is already zero.
            // Two cases arise:
            // 1) If there is a row below it
            // with non-zero entry, then swap
            // this row with that row and process
            // that row
            // 2) If all elements in current
            // column below mat[r][row] are 0,
            // then remove this column by
            // swapping it with last column and
            // reducing number of columns by 1.
            else
            {
                reduce = true;
     
                // Find the non-zero element
                // in current column
                for (var i = row + 1; i < R; i++)
                {
                    // Swap the row with non-zero
                    // element with this row.
                    if (mat[i][row] != 0)
                    {
                        swap(mat, row, i, rank);
                        reduce = false;
                        break ;
                    }
                }
     
                // If we did not find any row with
                // non-zero element in current
                // column, then all values in
                // this column are 0.
                if (reduce)
                {
                    // Reduce number of columns
                    rank--;
     
                    // Copy the last column here
                    for (i = 0; i < R; i ++)
                        mat[i][row] = mat[i][rank];
                }
     
                // Process this row again
                row--;
            }
     
        // Uncomment these lines to see
        // intermediate results display(mat, R, C);
        // printf(<br>);
        }
         
        return rank;
    }
     
    // Driver code
    var mat = [[10, 20, 10],
            [-20, -30, 10],
            [30, 50, 0]];
             
            document.write("Rank of the matrix is : "
                    + rankOfMatrix(mat));
 
// This code is contributed by Amit Katiyar
</script>
Producción

Rank of the matrix is : 2

Complejidad temporal: O(fila x columna x rango).
Espacio Auxiliar: O(1)

Dado que el método de cálculo de rango anterior implica aritmética de punto flotante, puede producir resultados incorrectos si la división va más allá de la precisión. Hay otros métodos para manejar.

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *