Wie drucke ich einzigartige Elemente im Perl-Array?

Ich bin das schieben von Elementen in ein array während einer while-Anweisung. Jedes element ist ein Lehrer-name. Es endet als doppelte Lehrer-Namen in den array, wenn die Schleife abgeschlossen ist. Manchmal sind Sie nicht direkt neben einander in der array -, manchmal sind Sie das.

Wie kann ich drucken Sie nur die eindeutigen Werte in diesem array nach seiner endgültigen Werte geschoben? Ohne zu analysieren, das gesamte array jedes mal, wenn ich drucken möchte ein element.

Heres der code, nach dem alles, was geschoben wurde, in das array:

$faculty_len = @faculty;
$i=0;
while ($i != $faculty_len)
{
        printf $fh '"'.$faculty[$i].'"';
        $i++;
}

Kommentar zu dem Problem

Verwenden Sie nicht ein array, sondern einen hash. Ich arrays verwenden so wenig wie möglich. Kommentarautor: reinierpost

Es ist nichts falsch mit arrays, wie lange, wie Sie verwendet werden, für was Sie gut sind. 🙂 Kommentarautor: Robert P

InformationsquelleAutor der Frage CheeseConQueso | 2009-01-13

use List::MoreUtils qw/ uniq /;
my @unique = uniq @faculty;
foreach ( @unique ) {
    print $_, "\n";
}

InformationsquelleAutor der Antwort innaM

33

Ihre beste Wette wäre, die Nutzung einer (grundsätzlich) built-in-tool, wie uniq (wie beschrieben von innaM).

Wenn Sie nicht die Fähigkeit haben, zu verwenden, uniq und bewahren wollen, um, können Sie mit grep zu simulieren.
```
my %seen;
my @unique = grep { ! $seen{$_}++ } @faculty;
# printing, etc.
```
Dieser erste gibt dir einen hash, wobei jeder Schlüssel jeden Eintrag. Dann, Sie iteriert über jedes element, das zählen, wie viele es gibt, und das hinzufügen der ersten. (Aktualisiert, mit Anmerkungen von brian d foy)

InformationsquelleAutor der Antwort Robert P

Schlage ich vor, schob es in einen hash.
wie diese:

my %faculty_hash = ();
foreach my $facs (@faculty) {
  $faculty_hash{$facs} = 1;
}
my @faculty_unique = keys(%faculty_hash);

InformationsquelleAutor der Antwort user54650

@array1 = ("abc", "def", "abc", "def", "abc", "def", "abc", "def", "xyz");

@array1 = grep { ! $seen{ $_ }++ } @array1;

print "@array1\n";

InformationsquelleAutor der Antwort prasad

5

Diese Frage beantwortet ist, mit mehreren Lösungen in perldoc. Geben Sie einfach an der Befehlszeile ein:
```
perldoc -q duplicate
```
InformationsquelleAutor der Antwort Bizmarck
4

Bitte beachten Sie: Einige der Antworten, die mit einem hash ändern Sie die Reihenfolge der array. Hashes haben nicht jede Art von Bestellung, so bekommen die Schlüssel oder Werte wird eine Liste mit einer unbestimmten bestellen.

Dieser doen nicht für grep { ! $seen{$_}++ } @faculty

InformationsquelleAutor der Antwort jmmeier
3

Dies ist ein Einzeiler Befehl drucken einzigartigen Linien, damit es angezeigt wird.
```
perl -ne '$seen{$_}++ || print $_' fileWithDuplicateValues
```
InformationsquelleAutor der Antwort VJain
2

Fand ich abgedroschen, 3-liner, genießen
```
my %uniq; 
undef @uniq(@non_uniq_array); 
my @uniq_array = keys %uniq; 
```
InformationsquelleAutor der Antwort ryansstack
2

Nur ein weiterer Weg, es zu tun, nützlich nur, wenn Sie nicht kümmern, um:
```
my %hash;
@hash{@faculty}=1;
my @unique=keys %hash;
```
Wenn Sie vermeiden möchten, deklarieren Sie eine neue variable, die Sie verwenden können, die irgendwie underdocumented Globale variable %_
```
@_{@faculty}=1;
my @unique=keys %_;
```
InformationsquelleAutor der Antwort psxls
0

Wenn Sie brauchen, um Prozess der Fakultät Liste in irgendeiner Weise, eine Karte über den array umgewandelt, um einen hash-Schlüssel für Koaleszenz-und dann Sortieren keys ist ein weiterer guter Weg:
```
my @deduped = sort keys %{{ map { /.*/? ($_,1):() } @faculty }};
print join("\n", @deduped)."\n";
```
Bearbeiten Sie die Liste durch ändern der /.*/ regex für die Auswahl oder die Analyse und die Erfassung entsprechend, und Sie können die Ausgabe einer oder mehr mutierten, nicht-eindeutige Schlüssel pro pass durch ($_,1):() beliebig Komplex sein.

Wenn Sie müssen, ändern Sie die data-in-flight mit einer substitution regex, sagen zu entfernen, die Punkte aus dem Namen (s/\.//g), dann ist eine substitution nach dem obigen Muster mutieren wird die ursprüngliche @faculty array aufgrund $_ aliasing. Sie können um $_ aliasing, indem Sie eine anonyme Kopie des @faculty array (siehe die so genannte "baby cart" - operator):
```
my @deduped = sort keys %{{ map {/.*/? do{s/\.//g; ($_,1)}:()} @{[ @faculty ]} }};
print join("\n", @deduped)."\n";
print "Unmolested array:\n".join("\n", @faculty)."\n";
```
In neueren Versionen von Perl, die Sie übergeben können keys eine hashref, und Sie können die nicht-destruktive substitution:
```
my @deduped = sort keys { map { /.*/? (s/\.//gr,1):() } @faculty };
```
Sonst, die grep oder $seen[$_]++ Lösungen, die anderswo vielleicht vorzuziehen.

InformationsquelleAutor der Antwort derekm

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.