How to push data to a multidimensional array?

The Problem is that you aren't properly declaring your variables. For every script, you should

use strict; use warnings;

This disallows common error sources, warns about iffy stuff, and forces you to properly declare all your variables.

By default, all undeclared variables are considered global. Therefore, in

for($i=0;$i<=9;$i++)
{
    @Space = ();
    push(@Hits,\@Space);
}

the @Space refers to the same array in each iteration. Ergo, all ten entries in @Hits are a reference to the same array. Let's inspect what @Hits actually is. We can do so with Data::Dumper or the Data::Dump module (the latter usually produces prettier output):

use Data::Dump;  # use Data::Dumper;
dd \@Hits;       # print Dumper \@Hits;

We get with Data::Dumper (easier to understand):

$VAR1 = [
          [
            1,
            3,
            5,
            7
          ],
          $VAR1->[0],
          $VAR1->[0],
          $VAR1->[0],
          $VAR1->[0],
          $VAR1->[0],
          $VAR1->[0],
          $VAR1->[0],
          $VAR1->[0],
          $VAR1->[0]
        ];

So I said the solution would be declaring your variables. Specifically, we want lexical variables. These variables are only visible inside the block where they are declared. This makes reasoning about code much easier. We can declare a lexical variable like so:

my $foo = 123;

When we have a loop like

my @Hits;
for my $i  (0 .. 9) {
  my @Space;
  push @Hits, \@Space;
}

then each time the my is executed, we get a new @Space. Oh, and I have used a foreach-loop, that iterates over the range 0 .. 9 with the (lexical) $i variable. I find this easier to understand than the C-style loops you used.

Because every element in @Hits now is a different arrayref, we get the expected data structure. As Data::Dump output:

[[], [1], [], [3], [], [5], [], [7], [], []]

When we now execute your loop that prints out the first value of each sub-array, then you may be suprised by the empty lines in between the numebers. This is because e.g. the first arrayref does not have an entry at index 0, and therefore returns the special undef value. When used as a string, this is the empty string. If you followed my advice and did the use warnings, you also get a message that you are printing an uninitialized value.

We can solve this by testing for definedness, and providing a zero otherwise. Since perl5 v10, we can use the defined-or operator // for this (on earlier perls, the || logical or has to do).

for my $i (0 .. 9) {
  my $value = $Hits[$i][0] // 0;
  print "$value\n";
}

There are a few other bits we can improve:

• We don't have to manually create the @Space arrays; Perl does this behind the scenes when you dereference an array entry like @{ $Hits[$i] }. This is called autovivification.
• Not only can we iterate over ranges, but also over arrays. This is much better than hardcoding indices.
• Since v10, you can use the say feature. The say function is exactly like print but appends a newline at the end.

Here is how I'd have written that code:

#!/usr/bin/perl
use strict; use warnings; use feature 'say';

my @Hits;

for my $i (1, 3, 5, 7) {
  push @{ $Hits[$i] }, $i;
}

for my $arrayref (@Hits) {
  say $arrayref->[0] // 0;
}

Output:

0
1
0
3
0
5
0
7

(Note that we never initialized values at positions 8 and 9, so they are not shown. We could amend this by iterating over the slice @Hits[0 .. 9].)