Sometimes it's easier to do it all backwards:

use strict;
use warnings;
use Data::Dumper;

my @a = ( 1, 2, 3, "a" );
my %Hash = do { my $hashref = 1;
                $hashref = { $_ => $hashref } for reverse @a;
                %{$hashref};
};

print Dumper \%Hash;
[download]

This algorithm is very similar to one used to create linked lists, demonstrated in Mastering Algorithms with Perl, published by O'Reilly & Associates.

The way this works is by assigning your final value to $hashref. Then you work backwards through @a, setting $hashref equal to $hashref->{a}=1, and then to $hashref->{3}{a}=1, and then to $hashref->{2}{3}{a}=1, and so on, each time adding one more higher layer. In the end, you asked for %Hash, not $hashref, so this snippet dereferences $hashref for you and hands you %Hash. The do{...} block is used to limit the scope of $hashref, and to compartmentalize the entire operation in one nice little package.

Enjoy!

See hash problem.

Also Array to nested hash. This Q ought to get put into the hash Q&A.

---

Caution: Contents may have been coded under pressure.

Off the top of my head, a relatively inefficient method:

eval '$Hash' . map { qq({'$_'}) } @a . ' = 1';
[download]

Untested, of course ;-) A bit of description in order here: we're just creating the string you wanted. A bit more smarts to only put in the quotes when required, check if the hash you're trying to create already exists as a scalar rather than a hashref, etc., to prevent collisions, ... but if you know that collisions can't happen, then this should be fine.

UPDATE:After reading the other hash thread, I see someone of importance saying "don't use eval". And, as a general rule, I would agree. But I don't know if this is a one-off script (just do a quick conversion, and never use it again), or if the input is tightly controlled (e.g., can't be manipulated to circumvent perl security-isms, e.g., a string that had single-quotes in it: qq(blah' . system("rm -rf /") . 'blah)), or other mitigating circumstances. Sometimes quick and dirty is fine. A more robust method would use loops or even recursion to do this.

sub create_hash_depth
{
  my $href = shift;
  my @a = @_;
  if (scalar @a > 1) {
    $href->{$a[0]} = {};
    create_hash_depth($href->{$a[0]}, @a[1..$#a]);
  } else {
    $href->{$a[0]} = 1;
  }
}
[download]

Or something like that

lol, i just read the other thread too. I have heard eval is dangerous to use. Thanks for all your help guys.

use strict;
use Data::Dumper;

my @a = (1, 2 ,3 , "a");
my %h;

a2h (\@a, \%h);

print Dumper (\%h);

print $h{1}{2}{3}{a};

sub a2h
{
    my $array = shift;
    my $hash  = shift;
    my $index = 0;

    while ( $index < $#$array )
    {
        $hash = $hash->{$array->[$index]} = {};
        $index++;
    }

    $hash->{$array->[$index]} = 1;

    return $hash;
}

#Output:
#
#$VAR1 = {
#          '1' => {
#                   '2' => {
#                            '3' => {
#                                     'a' => 1
#                                   }
#                          }
#                 }
#        };
#1
[download]