Perl 如何比较两个数组中的唯一元素

我有两个数组列表，我想找出其中是否有匹配的词，然后得到两个值

For examples 
array1        array2
int1<->int2   int9<->int1 --->Matched as Int1 is common. Get both the values(e.g int1<->int21,int9<-
int3<->int4   int10<->int11 ->> not matched
int5<->int6   int13<->int14-->> no matched
int7<->int8   int8<->int15 -- Macthed int8 Get $var1=int7<->int8,$var2=int8<->int15

以获取示例
阵列1阵列2
int1int2 int9int1-->匹配为Int1是常见的。获取两个值（例如int1int21、int9>不匹配
int5int6 int13int14-->不匹配
int7int8 int8int15——Macthed int8获取$var1=int7int8，$var2=int8int15

---

希望它有意义。如果有任何疑问，请让我知道。

您想要什么并不完全清楚，但可能是：

my @a = qw(int1<->int2 int3<->int4 int7<->int8);
my @b = qw(int9<->int1 int10<->int11 int8<->int15);

for my $i (0..$#a) {
  my ($w1, $w2) = ($a[$i] =~ /([^<]+)<->(.+)/);
  if (index($b[$i],$w1)!=-1 || index($b[$i],$w2)!=-1) {
    print "match: $a[$i], $b[$i]\n";
  }
}

my@a=qw（int1int2 int3int4 int7int8）；
my@b=qw（int9int1 int10int11 int8int15）；
我的$i（0..$#a）{
我的（$w1，$w2）=（$a[$i]=~/（[^你想要什么还不完全清楚，但也许这是：

my @a = qw(int1<->int2 int3<->int4 int7<->int8);
my @b = qw(int9<->int1 int10<->int11 int8<->int15);

for my $i (0..$#a) {
  my ($w1, $w2) = ($a[$i] =~ /([^<]+)<->(.+)/);
  if (index($b[$i],$w1)!=-1 || index($b[$i],$w2)!=-1) {
    print "match: $a[$i], $b[$i]\n";
  }
}

my@a=qw（int1int2 int3int4 int7int8）；
my@b=qw（int9int1 int10int11 int8int15）；
我的$i（0..$#a）{
我的（$w1，$w2）=（$a[$i]=~/（[^你想要什么还不完全清楚，但也许这是：

my @a = qw(int1<->int2 int3<->int4 int7<->int8);
my @b = qw(int9<->int1 int10<->int11 int8<->int15);

for my $i (0..$#a) {
  my ($w1, $w2) = ($a[$i] =~ /([^<]+)<->(.+)/);
  if (index($b[$i],$w1)!=-1 || index($b[$i],$w2)!=-1) {
    print "match: $a[$i], $b[$i]\n";
  }
}

my@a=qw（int1int2 int3int4 int7int8）；
my@b=qw（int9int1 int10int11 int8int15）；
我的$i（0..$#a）{
我的（$w1，$w2）=（$a[$i]=~/（[^你想要什么还不完全清楚，但也许这是：

my @a = qw(int1<->int2 int3<->int4 int7<->int8);
my @b = qw(int9<->int1 int10<->int11 int8<->int15);

for my $i (0..$#a) {
  my ($w1, $w2) = ($a[$i] =~ /([^<]+)<->(.+)/);
  if (index($b[$i],$w1)!=-1 || index($b[$i],$w2)!=-1) {
    print "match: $a[$i], $b[$i]\n";
  }
}

my@a=qw（int1int2 int3int4 int7int8）；
my@b=qw（int9int1 int10int11 int8int15）；
我的$i（0..$#a）{
my（$w1，$w2）=（$a[$i]=~/（[^一个稍高级的解决方案，它将一个键转换为用于比较的列表正则表达式。因此捕获匹配的键：

my @a = qw(int1<->int2 int3<->int4 int7<->int8);
my @b = qw(int9<->int1 int10<->int11 int8<->int15);

for my $i (0..$#a) {
    my $list_re = join '|', map quotemeta, split '<->', $a[$i];
    if ($b[$i] =~ /\b($list_re)\b/) {
        print "match $1: $a[$i], $b[$i]\n";
    }
}

my@a=qw（int1int2 int3int4 int7int8）；
my@b=qw（int9int1 int10int11 int8int15）；
我的$i（0..$#a）{
我的$list_re=join'|'，map quotemeta，split''，$a[$i]；
如果（$b[$i]=~/\b（$list\u re）\b/）{
打印“匹配$1:$a[$i]，$b[$i]\n”；
}
}
一个稍微更完善的解决方案，它将一个键转换为用于比较的列表正则表达式。因此捕获匹配的键：

my @a = qw(int1<->int2 int3<->int4 int7<->int8);
my @b = qw(int9<->int1 int10<->int11 int8<->int15);

for my $i (0..$#a) {
    my $list_re = join '|', map quotemeta, split '<->', $a[$i];
    if ($b[$i] =~ /\b($list_re)\b/) {
        print "match $1: $a[$i], $b[$i]\n";
    }
}

my@a=qw（int1int2 int3int4 int7int8）；
my@b=qw（int9int1 int10int11 int8int15）；
我的$i（0..$#a）{
我的$list_re=join'|'，map quotemeta，split''，$a[$i]；
如果（$b[$i]=~/\b（$list\u re）\b/）{
打印“匹配$1:$a[$i]，$b[$i]\n”；
}
}
一个稍微更完善的解决方案，它将一个键转换为用于比较的列表正则表达式。因此捕获匹配的键：

my @a = qw(int1<->int2 int3<->int4 int7<->int8);
my @b = qw(int9<->int1 int10<->int11 int8<->int15);

for my $i (0..$#a) {
    my $list_re = join '|', map quotemeta, split '<->', $a[$i];
    if ($b[$i] =~ /\b($list_re)\b/) {
        print "match $1: $a[$i], $b[$i]\n";
    }
}

my@a=qw（int1int2 int3int4 int7int8）；
my@b=qw（int9int1 int10int11 int8int15）；
我的$i（0..$#a）{
我的$list_re=join'|'，map quotemeta，split''，$a[$i]；
如果（$b[$i]=~/\b（$list\u re）\b/）{
打印“匹配$1:$a[$i]，$b[$i]\n”；
}
}
一个稍微更完善的解决方案，它将一个键转换为用于比较的列表正则表达式。因此捕获匹配的键：

my @a = qw(int1<->int2 int3<->int4 int7<->int8);
my @b = qw(int9<->int1 int10<->int11 int8<->int15);

for my $i (0..$#a) {
    my $list_re = join '|', map quotemeta, split '<->', $a[$i];
    if ($b[$i] =~ /\b($list_re)\b/) {
        print "match $1: $a[$i], $b[$i]\n";
    }
}

my@a=qw（int1int2 int3int4 int7int8）；
my@b=qw（int9int1 int10int11 int8int15）；
我的$i（0..$#a）{
我的$list_re=join'|'，map quotemeta，split''，$a[$i]；
如果（$b[$i]=~/\b（$list\u re）\b/）{
打印“匹配$1:$a[$i]，$b[$i]\n”；
}
}
与ooga相比，这是一种稍微费力的方法。我说的是一种不太流利的Perl版本

该脚本将数据分成数组，并通过匹配和保持子模式
=~/（）…（）/
并将其存储为变量来创建两个模式（与ooga的方法基本相同）。然后我使用第二个正则表达式循环通过其中一个数组，将每个元素与另一个数组的元素进行匹配。对于更复杂的字符串、分布不均匀的数据或更大的数据集，我不确定
foreach
if..elsif
逻辑可能不会遗漏什么。不过，作为快速测试，我将下面的脚本与oo进行了比较ga的工作，它们给出相同的输出；-）

smartmatch（
~~
）或可能在较新版本的Perl中工作

#!/usr/bin/env perl

use strict;
use warnings;

my (@col1, @col2);

while (<DATA>) {
  chomp; my @data =  split/ / ;
  push @col1, $data[0];
  push @col2, $data[1];
}

foreach my $i (0 .. $#col1 ) {
  my ($patt1, $patt2) = ( $col1[$i] =~ /([^<]+)<->(.+)/ );
  if ($col2[$i] =~ $patt1 ) { 
    print "$col1[$i] matches $col2[$i]  \n";
  }
  elsif ($col2[$i] =~ $patt2 ) {
    print "$col1[$i] matches $col2[$i]  \n";
  }
}

__DATA__
int1<->int2 int9<->int1
int3<->int4 int10<->int11
int5<->int6 int13<->int14
int7<->int8 int8<->int15 

！/usr/bin/env perl
严格使用；
使用警告；
我的（@col1，@col2）；
而（）{
chomp；my@data=split/；
推送@col1，$data[0]；
推送@col2，$data[1]；
}
每个我的$i（0..$#col1）{
我的（$patt1，$patt2）=（$col1[$i]=~/（[^这是一种比ooga采取的方法稍微费力的方法。我在这里讲的是一个不太流利的Perl版本：-）

该脚本将数据分成数组，并通过匹配和保持子模式
=~/（）…（）/
并将其存储为变量来创建两个模式（与ooga的方法基本相同）。然后我使用第二个正则表达式循环通过其中一个数组，将每个元素与另一个数组的元素进行匹配。对于更复杂的字符串、分布不均匀的数据或更大的数据集，我不确定
foreach
if..elsif
逻辑可能不会遗漏什么。不过，作为快速测试，我将下面的脚本与oo进行了比较ga的工作，它们给出相同的输出；-）

smartmatch（
~~
）或可能在较新版本的Perl中工作

#!/usr/bin/env perl

use strict;
use warnings;

my (@col1, @col2);

while (<DATA>) {
  chomp; my @data =  split/ / ;
  push @col1, $data[0];
  push @col2, $data[1];
}

foreach my $i (0 .. $#col1 ) {
  my ($patt1, $patt2) = ( $col1[$i] =~ /([^<]+)<->(.+)/ );
  if ($col2[$i] =~ $patt1 ) { 
    print "$col1[$i] matches $col2[$i]  \n";
  }
  elsif ($col2[$i] =~ $patt2 ) {
    print "$col1[$i] matches $col2[$i]  \n";
  }
}

__DATA__
int1<->int2 int9<->int1
int3<->int4 int10<->int11
int5<->int6 int13<->int14
int7<->int8 int8<->int15 

！/usr/bin/env perl
严格使用；
使用警告；
我的（@col1，@col2）；
而（）{
chomp；my@data=split/；
推送@col1，$data[0]；
推送@col2，$data[1]；
}
每个我的$i（0..$#col1）{
我的（$patt1，$patt2）=（$col1[$i]=~/（[^这是一种比ooga采取的方法稍微费力的方法。我在这里讲的是一个不太流利的Perl版本：-）

该脚本将数据分成数组，并通过匹配和保持子模式
=~/（）…（）/
并将其存储为变量来创建两个模式（与ooga的方法基本相同）。然后我使用第二个正则表达式循环通过其中一个数组，将每个元素与另一个数组的元素进行匹配。对于更复杂的字符串、分布不均匀的数据或更大的数据集，我不确定
foreach
if..elsif
逻辑可能不会遗漏什么。不过，作为快速测试，我将下面的脚本与oo进行了比较ga的工作，它们给出相同的输出；-）

智能匹配（
~
），或者可能是