将数组中的每个元素添加到 Perl 中的复杂散列中

Question

我有一个包含 n 个元素的数组。我想将每个元素添加到一个复杂的哈希中，每个元素都作为一个键/值对。如果元素的数量是固定的，比如三个，我会这样做：

my %hash;
my @array = ("first", "second", "third");
$hash{$array[0]}{$array[1]}{$array[2]}++;

我想最终得到的结构是这样的（用 Data::Dumper 打印）：

$VAR1 = 'first';
$VAR2 = {
        'second' => {
                   'third' => 1
};

但是当数组中的元素数量不固定时，我无法实现相同的结构。带有匿名变量并遍历数组的东西，是的，但是像

foreach @array{$hash{$_}++};

显然每个元素只会输入一个条目，而不是所需的结构。帮助？

Answer 1

这样的东西可以为 N 个元素构建你想要的结构：

use strict;
use warnings; 

use Data::Dumper;
my @array = qw(first second third four five six seven);

my $hash;
foreach my $key ( reverse @array ) {
   $hash = { $key => $hash };
}
print Dumper $hash;

__END__
$VAR1 = {
      'first' => {
                   'second' => {
                                 'third' => {
                                              'fourth' => {
                                                          'fifth' => {
                                                                      'sixth' => {
                                                                                 'seventh' => undef
                                                                               }
                                                                    }
                                                        }
                                            }
                               }
                 }
    };

不清楚你真正需要这个做什么。如果您多解释一下您的用例，可能会有更好的解决方案。增加这个结构似乎并不容易。

玩了一会儿之后，您可以通过遍历哈希引用到底部然后递增最后一个元素的值来递增。虽然不是很漂亮：|

# incrementing
my $elem = $hash; # copy the reference 
foreach my $key ( @array ) {
   # found the bottom of the hash
   unless ( $elem->{$key} && ref($elem->{$key}) ) { 
      $elem->{$key}++;
      last; 
   }

   # not at the bottom, move to the next level
   $elem = $elem->{$key};
}
print Dumper $hash;

__END__
$VAR1 = {
      'first' => {
                   'second' => {
                                 'third' => {
                                              'fourth' => {
                                                            'fifth' => {
                                                                         'sixth' => {
                                                                                      'seventh' => 1
                                                                                    }
                                                                       }
                                                          }
                                            }
                               }
                 }
    };

Answer 2

如果您维护 当前哈希 引用，这相对简单。这个小程序演示了

前几个步骤确保每个散列元素都存在并且它的值是一个散列引用。 $href 在每个阶段移动到下一个哈希级别。对于数组的最后一个元素，最新的哈希级别的元素是递增的，而不是设置为哈希引用。

这个数据结构是否是正确的选择取决于你在构建它之后还需要做什么

use strict;
use warnings;

my %hash;
my @array = qw/ first second third fourth fifth /;

drill_hash(\%hash, @array);

use Data::Dump;
dd \%hash;

sub drill_hash {
  my ($href, @list) = @_;
  my $final = pop @list;
  $href = $href->{$_} //= {} for @list;
  ++$href->{$final};
}

输出

{
  first => { second => { third => { fourth => { fifth => 1 } } } },
}

---

更新

了解您的目的后，保持此类 ngram 出现次数的最简单方法是拥有一个特定的哈希键，用于保持到目前为止单词序列的 count。

该程序使用值_COUNT 作为该键，例如，您可以看到{under}{a}{_COUNT} 和{under}{a}{rock}{_COUNT} 都是1

use strict;
use warnings;

my %counts;

count_ngram(\%counts, qw/ under a /);
count_ngram(\%counts, qw/ a rock /);
count_ngram(\%counts, qw/ under a rock /);
count_ngram(\%counts, qw/ a tree /);
count_ngram(\%counts, qw/ under a tree /);

use Data::Dump;
dd \%counts;

sub count_ngram {
  my ($href, @ngram) = @_;
  my $final = pop @ngram;
  $href = $href->{$_} //= {} for @ngram;
  ++$href->{$final}{_COUNT};
}

输出

{
  a => { rock => { _COUNT => 1 }, tree => { _COUNT => 1 } },
  under => {
    a => { _COUNT => 1, rock => { _COUNT => 1 }, tree => { _COUNT => 1 } },
  },
}