¿Cómo elimino elementos duplicados de una matriz en Perl?

Question

Tengo una matriz en Perl:

my @my_array = ("one","two","three","two","three");

¿Cómo elimino los duplicados de la matriz?

Answer 1

Puedes hacer algo como esto como se demuestra en perlfaq4:

sub uniq {
    my %seen;
    grep !$seen{$_}++, @_;
}

my @array = qw(one two three two three);
my @filtered = uniq(@array);

print "@filtered\n";

Salidas:

one two three

Si desea utilizar un módulo, pruebe el uniq función de List::MoreUtils

Answer 2

La documentación de Perl viene con una buena colección de preguntas frecuentes.Tu pregunta es frecuente:

% perldoc -q duplicate

La respuesta, copiada y pegada del resultado del comando anterior, aparece a continuación:

Found in /usr/local/lib/perl5/5.10.0/pods/perlfaq4.pod
 How can I remove duplicate elements from a list or array?
   (contributed by brian d foy)

   Use a hash. When you think the words "unique" or "duplicated", think
   "hash keys".

   If you don't care about the order of the elements, you could just
   create the hash then extract the keys. It's not important how you
   create that hash: just that you use "keys" to get the unique elements.

       my %hash   = map { $_, 1 } @array;
       # or a hash slice: @hash{ @array } = ();
       # or a foreach: $hash{$_} = 1 foreach ( @array );

       my @unique = keys %hash;

   If you want to use a module, try the "uniq" function from
   "List::MoreUtils". In list context it returns the unique elements,
   preserving their order in the list. In scalar context, it returns the
   number of unique elements.

       use List::MoreUtils qw(uniq);

       my @unique = uniq( 1, 2, 3, 4, 4, 5, 6, 5, 7 ); # 1,2,3,4,5,6,7
       my $unique = uniq( 1, 2, 3, 4, 4, 5, 6, 5, 7 ); # 7

   You can also go through each element and skip the ones you've seen
   before. Use a hash to keep track. The first time the loop sees an
   element, that element has no key in %Seen. The "next" statement creates
   the key and immediately uses its value, which is "undef", so the loop
   continues to the "push" and increments the value for that key. The next
   time the loop sees that same element, its key exists in the hash and
   the value for that key is true (since it's not 0 or "undef"), so the
   next skips that iteration and the loop goes to the next element.

       my @unique = ();
       my %seen   = ();

       foreach my $elem ( @array )
       {
         next if $seen{ $elem }++;
         push @unique, $elem;
       }

   You can write this more briefly using a grep, which does the same
   thing.

       my %seen = ();
       my @unique = grep { ! $seen{ $_ }++ } @array;

Answer 3

Instalar Lista::MásUtilidades de CPAN

Luego en tu código:

use strict;
use warnings;
use List::MoreUtils qw(uniq);

my @dup_list = qw(1 1 1 2 3 4 4);

my @uniq_list = uniq(@dup_list);

Answer 4

Mi forma habitual de hacer esto es:

my %unique = ();
foreach my $item (@myarray)
{
    $unique{$item} ++;
}
my @myuniquearray = keys %unique;

Si usa un hash y agrega los elementos al hash.También tienes la ventaja de saber cuántas veces aparece cada elemento en la lista.

Answer 5

Se puede hacer con una simple línea de Perl.

my @in=qw(1 3 4  6 2 4  3 2 6  3 2 3 4 4 3 2 5 5 32 3); #Sample data 
my @out=keys %{{ map{$_=>1}@in}}; # Perform PFM
print join ' ', sort{$a<=>$b} @out;# Print data back out sorted and in order.

El bloque PFM hace esto:

Los datos en @in se introducen en MAP.MAP construye un hash anónimo.Las claves se extraen del hash y se introducen en @out

Answer 6

La variable @array es la lista con elementos duplicados

%seen=();
@unique = grep { ! $seen{$_} ++ } @array;

Answer 7

Ese último estuvo bastante bien.Simplemente lo modificaría un poco:

my @arr;
my @uniqarr;

foreach my $var ( @arr ){
  if ( ! grep( /$var/, @uniqarr ) ){
     push( @uniqarr, $var );
  }
}

Creo que esta es probablemente la forma más legible de hacerlo.

Answer 8

Método 1:Usa un hash

Lógica:Un hash solo puede tener claves únicas, por lo tanto, itere sobre la matriz, asigne cualquier valor a cada elemento de la matriz y mantenga el elemento como clave de ese hash.Claves de retorno del hash, es su matriz única.

my @unique = keys {map {$_ => 1} @array};

Método 2:Ampliación del método 1 para la reutilización.

Es mejor crear una subrutina si se supone que debemos usar esta funcionalidad varias veces en nuestro código.

sub get_unique {
    my %seen;
    grep !$seen{$_}++, @_;
}
my @unique = get_unique(@array);

Método 3:Usar módulo List::MoreUtils

use List::MoreUtils qw(uniq);
my @unique = uniq(@array);

Answer 9

Las respuestas anteriores resumen prácticamente las posibles formas de realizar esta tarea.

Sin embargo, sugiero una modificación para aquellos que no preocuparse contando los duplicados, pero hacer preocuparnos por el orden.

my @record = qw( yeah I mean uh right right uh yeah so well right I maybe );
my %record;
print grep !$record{$_} && ++$record{$_}, @record;

Tenga en cuenta que lo sugerido anteriormente grep !$seen{$_}++ ... incrementos $seen{$_} antes de negar, por lo que el incremento se produce independientemente de si ya ha sido %seen O no.Lo anterior, sin embargo, produce cortocircuito cuando $record{$_} es cierto, dejando lo que se ha escuchado una vez "fuera del %record'.

También podrías optar por esta ridiculez, que aprovecha la autovivificación y la existencia de claves hash:

...
grep !(exists $record{$_} || undef $record{$_}), @record;

Sin embargo, esto podría generar cierta confusión.

Y si no te importa ni el orden ni el recuento de duplicados, puedes realizar otro truco usando cortes de hash y el truco que acabo de mencionar:

...
undef @record{@record};
keys %record; # your record, now probably scrambled but at least deduped

Answer 10

Pruebe esto, parece que la función uniq necesita una lista ordenada para funcionar correctamente.

use strict;

# Helper function to remove duplicates in a list.
sub uniq {
  my %seen;
  grep !$seen{$_}++, @_;
}

my @teststrings = ("one", "two", "three", "one");

my @filtered = uniq @teststrings;
print "uniq: @filtered\n";
my @sorted = sort @teststrings;
print "sort: @sorted\n";
my @sortedfiltered = uniq sort @teststrings;
print "uniq sort : @sortedfiltered\n";

Answer 11

Usando el concepto de claves hash únicas:

my @array  = ("a","b","c","b","a","d","c","a","d");
my %hash   = map { $_ => 1 } @array;
my @unique = keys %hash;
print "@unique","\n";

Producción:acbd