perl | Arrays multidimensionales

Las arrays multidimensionales en Perl son las arrays con más de una dimensión. Técnicamente, no existe una array multidimensional en Perl, pero las arrays se utilizan para actuar porque tienen más de una dimensión. Las arrays multidimensionales se representan en forma de filas y columnas, también conocidas como arrays. Cada elemento de una array puede ser una referencia a otra array, pero en la sintaxis, aparecerán como una array bidimensional. 

Una array multidimensional solo puede contener valores escalares, no puede contener arrays ni hashes.

Inicialización y declaración de un arreglo multidimensional

A continuación se muestra el ejemplo que aclara la inicialización y declaración de una array multidimensional. 
En este ejemplo, simplemente inicializaremos la array con @array_name = ([…], […], […]); . 

#!/usr/bin/perl
use strict;
use warnings;
 
# Initializing and defining the array
my @items = ( ['book', 'pen', 'pencil'],
              ['Bat', 'Ball', 'Stumps'],
              ['snake', 'rat', 'rabbit'] );
 
# Printing items from the array
print $items[0][0], "\n";
print $items[1][1], "\n";
print $items[2][2], "\n";

Producción: 

Crear una array

Matrix es una colección de filas y columnas de arrays que parece estar en más de una dimensión. 
Veamos un ejemplo para que quede más claro de crear una array en Perl.

Ejemplo 1: 
En este ejemplo, primero declaramos tres arrays con valores y luego las fusionamos en una array resultante final para formar una array de 3*3. Para controlar la variable $m y $n , ​​se utilizan dos bucles for. 

#!/usr/bin/perl
use strict;
use warnings;
 
# Array Declaration
my @arrayA = qw(1 0 0); 
my @arrayB = qw(0 1 0); 
my @arrayC = qw(0 0 1); 
 
# Merging 3 arrays into One Final array 
my @result = (\@arrayA, \@arrayB, \@arrayC);
  
print "Resultant 3*3 Matrix:\n"; 
 
# Using For loop
for(my $m = 0; $m <= $#result; $m++)
{  
   for(my $n = 0; $n <= $#result ; $n++)
   { 
      print "$result[$m][$n] "; 
   } 
   print "\n"; 
} 

Producción: 

Ejemplo 2: 
En este ejemplo, tomaremos la entrada del teclado y luego sumaremos las dos arrays e imprimiremos el resultado usando la array resultante. 

#!usr/bin/perl
use strict;
use warnings;
 
my (@MatrixA, @MatrixB, @Resultant) = ((), (), ());
 
# Asking for User Input for Matrix A
print "Please Provide the order of MatrixA :\n";
print "\tMatrixA rows:";
chomp(my $rowA = <>);  # CHOMP TO TAKE USER INPUT
print "\tMatrixA columns:";
chomp(my $columnA = <>);
 
# Asking for User Input for Matrix B
print "Please Provide the order of MatrixB :\n";
print "\tMatrixB rows:";
chomp(my $rowB = <>);
print "\tMatrixB columns:";
chomp(my $columnB = <>);
 
# Asking User to input elements of matrices
if ($rowA == $rowB and $columnA == $columnB)
{
    print "Enter $rowA * $columnA elements in MatrixA:\n";
    foreach my $m (0..$rowA - 1)
    {
        foreach my $n (0..$columnA - 1)
        {
            chomp($MatrixA[$m][$n] = <>);  # TO READ THE VALUES
        }
    }
     
    print "Enter $rowB * $columnB elements in MatrixB:\n";
    foreach my $m (0..$rowB - 1)
    {
        foreach my $n (0..$columnB - 1)
        {
            chomp($MatrixB[$m][$n] = <>);  # TO READ THE VALUES
        }
    }
     
    # Performing Addition operation
    foreach my $m (0..$rowB - 1)
    {
        foreach my $n (0..$columnB - 1)
        {
            $Resultant[$m][$n] = $MatrixA[$m][$n] +
                                 $MatrixB[$m][$n];
        }
    }
     
    # Printing Matrix A
    print "MatrixA is :\n";
    foreach my $m (0..$rowB - 1)
    {
        foreach my $n (0..$columnB - 1)
        {
            print "$MatrixA[$m][$n] ";
        }
        print "\n";
    }
     
    # Printing Matrix B
    print "MatrixB is :\n";
    foreach my $m (0..$rowB - 1)
    {
        foreach my $n (0..$columnB - 1)
        {
            print "$MatrixB[$m][$n] ";
        }
        print "\n";
    }
     
    # Printing the sum of Matrices
    print "SUM of MatrixA and MatrixB is :\n";
    foreach my $m (0..$rowB - 1)
    {
        foreach my $n (0..$columnB - 1)
        {
            print "$Resultant[$m][$n] ";
        }
        print "\n";
    }
}
 
# Error if Matrices are of different order
else
{
    print "Matrices order does not MATCH, Addition is not Possible";
}

Producción: 

La suma de arrays solo se puede realizar si las arrays son del mismo orden.  

Array de arrays

Array de arrays son las estructuras de datos que tienen una array que tiene una lista de referencias de array. Los elementos dentro de una array son las referencias de la array. Estas referencias se pueden imprimir individualmente o también se puede imprimir toda la array, según el requisito. 

Sintaxis: 

@ARRAY_NAME = ([value1], [value2], [value3], ..., [valueN]);

Ejemplo 1:  

#!/usr/bin/perl
use strict;
use warnings;
 
# Array of Arrays
my @GfG = ( ["Geek",  "For",  "Geeks"],
            ["Is",    "Best", "For"],
            ["Those", "In",  "Need"] );
 
# Printing internal array elements
print "Accessing Array elements:\n";
print  @{$GfG[0]}[1], "\n"; # For accessing particular array element
print  @{$GfG[1]}[0], "\n";
print  @{$GfG[2]}[2], "\n";
 
# Printing whole Arrays
print "\nAccessing whole arrays: \n";
print @{$GfG[0]}, "\n"; # For accessing particular array
print @{$GfG[1]}, "\n";
print @{$GfG[2]}, "\n";
print "\n";

Producción: 

Ejemplo 2: 

En este ejemplo, generamos una array de arrays utilizando una única array.  

#!/usr/bin/perl
use strict;
use warnings;
use Data::Dumper;
 
my @GfG = ( ["SAM",  "SHABANAM",  "SOHAM"],
            ["DHONI", "GONI", "AVNI"],
            ["VIRAT", "STUART", "ROHIT"] );
my @test;
foreach (@GfG)
{
    if ($_ =~ /M/ )
    {
        push ( @{$test[0]}, $_);
    }
    elsif ($_ =~ /I/ )
    {
        push ( @{$test[1]}, $_);
    }
    else
    {
        push ( @{$test[2]}, $_);
    }
}
 
print Dumper(\@test), "\n";

Producción: 

Array de hashes

La array de hashes es la estructura de datos donde la array tiene una lista de hashes. Las referencias hash son los objetos de una array. Para acceder a la clave y los valores, debemos desreferenciarlos. 
La array de hashes es una excelente estructura de datos si queremos recorrer los hashes numéricamente. 

Sintaxis:  

@ARRAY_NAME = ({KEY1 => VALUE1}, {KEY2 => VALUE2});

Ejemplo 1:  

#!/usr/bin/perl
use strict;
use warnings;
 
my @hashtest = ({ First => "Geek",
                  Middle => "For",
                  Last => "Geeks" },
                { Street => "Royal Kapsons",
                  City => "Noida-Uttar Pradesh" },
                { About => "Computer Science portal",
                  Content => "Technical" });
 
# To access any of the hash reference.
print $hashtest[0], "\n";
 
# To access keys of any hash reference.
print keys %{$hashtest[2]}, "\n";
 
# To access any value of any key.
print $hashtest[0]->{"First"}, "\n";
print $hashtest[0]->{"Middle"}, "\n";
print $hashtest[0]->{"Last"}, "\n";

Producción: 

Ejemplo 2: 
generar una array de hashes a partir de una array simple. 

#!/usr/bin/perl
use strict;
use warnings;
 
use Data::Dumper;
 
my @array = ("Item - Java Course",
             "Cost - 5000",
             "Ratings - 5 star");
 
# Empty array of hashes
my @array_1;
 
foreach (@array)
{
    my @array = split(" - ", $_);
    $array_1[0]->{$array[0]} = $array[1];
}
 
print Dumper (\@array_1);

Producción: