Perl | Multidimensional Arrays
Last Updated :
14 Sep, 2021
Multidimensional arrays in Perl are the arrays with more than one dimension. Technically there is no such thing as a multidimensional array in Perl but arrays are used to act as they have more than one dimension. Multi dimensional arrays are represented in the form of rows and columns, also knows as matrix. Each element of an array can be a reference to another array but in syntax, they will appear like a 2-dimensional array.
A multidimensional array can only hold scalar values, they can not hold arrays or hashes.
Initialization and Declaration of a Multidimensional Array
Given below is the example that makes clear the initialization and declaration of a Multidimensional array.
In this example we will simply initialize the array by @array_name = ([...], [...], [...]);.
Perl
#!/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";
Output:
Creating a Matrix
Matrix is a collection of rows and columns of arrays that appears to be in more than one dimension.
Let's see an example to make it more clear of creating a matrix in Perl.
Example 1:
In this example, we first declared three arrays with values and then merged them into a final resulted array to form a 3*3 matrix. In order to control the variable $m and $n, two for loops are used.
Perl
#!/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";
}
Output:
Example 2:
In this example, we will take the input from the keyboard and then add the two matrices and printing the result using the resultant matrix.
Perl
#!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";
}
Output:
Addition of Matrices can only be performed if the matrices are of the same order.
Array of Arrays
Array of Arrays are the data structures having an array having list of array references. Elements inside an array are the array references. These references can be printed individually or the whole array can be printed as well, as per the requirement.
Syntax:
@ARRAY_NAME = ([value1], [value2], [value3], ..., [valueN]);
Example 1:
Perl
#!/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";
Output:
Example 2:
In this example, we generated an array of array by using a single array.
Perl
#!/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";
Output:
Array of Hashes
Array of hashes is the data structure where the array has a list of hashes. Hash references are the objects of an array. In order to access the key and values, we need to de-reference them.
Array of hashes is a great data structure if we want to loop through hashes numerically.
Syntax:
@ARRAY_NAME = ({KEY1 => VALUE1}, {KEY2 => VALUE2});
Example 1:
Perl
#!/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";
Output:
Example 2:
Generating an array of hashes from a simple array.
Perl
#!/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);
Output:
Similar Reads
Multidimensional Array in R
Arrays are the R data objects which can store data in more than two dimensions. For example: If we create an array of dimensions (2, 3, 4) then it creates 4 rectangular matrices each with 2 rows and 3 columns. These types of arrays are called Multidimensional Arrays. Arrays can store only data types
3 min read
Perl | Multidimensional Hashes
Prerequisite: Hashes-Basics Introduction Beyond the normal constraints of the hashes, we can also create complex structures made up of combinations of two. These are nested or complex structures and they can be used to model complex data in an easy-to-use format. Among all of the Perl's nested struc
6 min read
C++ Multidimensional Array
A multidimensional array is an array with more than one dimension. It means that it can grow in different directions i.e. instead of changing the length only, it can also change in width, depth or more.Syntax of Multidimensional ArraysC++data_type array_name[s1][s2]...[sn];where s1, s2,…, sn are the
8 min read
Multidimensional Arrays in Scala
In Scala, multidimensional arrays can be represented as arrays of arrays, where each nested array represents a row or a column. The size of the array can be defined using two integer values representing the number of rows and columns, respectively. Here's an example code with output that demonstrate
4 min read
Multidimensional Arrays in Excel VBA
Multidimensional Arrays are used to store data of similar data types of more than one dimension. A multidimensional array has a dimension up to 60 but usually, we don't use arrays of dimensions more than 3 or 4. Here, we will see how to declare a multidimensional array in many ways and also how to c
2 min read
JavaScript Multidimensional Array
A multidimensional array in JavaScript is an array that contains other arrays as its elements. These are often used to represent data in a grid or matrix format. In JavaScript, there is no direct syntax for multidimensional arrays, but you can achieve this by creating arrays within arrays.Creating a
4 min read
One Dimensional Arrays in C++
One-dimensional arrays are like a row of boxes where you can store things where each box can hold one item, such as a number or a word. For example, in an array of numbers, the first box might hold 5, the second 10, and so on. You can easily find or change what's in each box by referring to its posi
6 min read
One Dimensional Arrays in C
In C, an array is a collection of elements of the same type stored in contiguous memory locations. This organization allows efficient access to elements using their index. Arrays can also be of different types depending upon the direction/dimension they can store the elements. It can be 1D, 2D, 3D,
5 min read
Java Multi-Dimensional Arrays
Multidimensional arrays are used to store the data in rows and columns, where each row can represent another individual array are multidimensional array. It is also known as array of arrays. The multidimensional array has more than one dimension, where each row is stored in the heap independently. T
10 min read
How to iterate a Multidimensional Array?
Multidimensional arrays are arrays that have more than one dimension. For example, a simple array is a 1-D array, a matrix is a 2-D array, and a cube or cuboid is a 3-D array but how to visualize arrays with more than 3 dimensions, and how to iterate over elements of these arrays? It is simple, just
8 min read