Verschachtelung spärlich sortiert Arrays

Ich bin nicht wirklich sicher, was das entweder genannt werden würde, aber ich herausgefunden eine Möglichkeit, die Reihenfolge der Anordnung von Arrays als eine Eingabe gegeben zu finden. Im Wesentlichen des Pseudo-Code ist:

10 Finden früheste Artikel in allen Arrays
20 Drücken Sie, dass auf einer Liste
30 das Element entfernen aus allen Arrays
40 Goto 10 , wenn es irgendwelche Reststücke

Hier ist ein funktionsfähiger Prototyp:

#!/usr/bin/perl

use strict;

sub InList {
    my ($x, @list) = @_;
    for (@list) {
        return 1 if $x eq $_;
    }
    return 0;
}

sub Earliest {
    my @lists = @_;
    my $earliest;
    for (@lists) {
        if (@$_) {
            if (!$earliest
                || ($_->[0] ne $earliest && InList($earliest, @$_))) {

                $earliest = $_->[0];
            }
        }
    }
    return $earliest;
}

sub Remove {
    my ($x, @lists) = @_;

    for (@lists) {
        my $n = 0;
        while ($n < @$_) {
            if ($_->[$n] eq $x) {
                splice(@$_,$n,1);
            }
            else {
                $n++
            }
        }
    }
}

my $list = [
    [ 'do', 're', 'fa', 'ti' ],
    [ 'do', 're', 'mi' ],
    [ 'do', 'la', 'ti', 'za' ],
    [ 'mi', 'fa' ],
    [ 're', 'so', 'za' ]
];

my @items;

while (my $earliest = Earliest(@$list)) {
    push @items, $earliest;
    Remove($earliest, @$list);
}

print join(',', @items);

Ausgabe:

do, re, mi, fa, la, ti, so, za

Lösung:

Dies löst die ursprüngliche Frage, bevor es durch die Fragesteller geändert wurde.

#!/usr/local/bin/perl -w
use strict; 

   main();

   sub main{
      # Changed your 3-dimensional array to a 2-dimensional array
      my @old = (
                   [ 'do', 're', 'fa', 'ti' ],
                   [ 'do', 're', 'mi' ],
                   [ 'do', 'la', 'ti', 'za' ],
                   [ 'mi', 'fa' ],
                   [ 're', 'so', 'za' ]
                );
      my %new;

      foreach my $row (0.. $#old ){                           # loop through each record (row)
         foreach my $col (0..$#{$old[$row]} ){                # loop through each element (col)                    
            $new{ ${$old[$row]}[$col] }{count}++;
            push @{ $new{${$old[$row]}[$col]}{position} } , [$row,$col];
         }
      }

      foreach my $key (sort keys %new){
         print "$key : $new{$key} " , "\n";                   # notice each value is a hash that we use for properties 
      }      
   } 

Wie Abrufen Info:

   local $" = ', ';                       # pretty print ($") of array in quotes
   print $new{za}{count} , "\n";          # 2    - how many there were
   print "@{$new{za}{position}[1]} \n";   # 4,2  - position of the second occurrence
                                          #        remember it starts at 0   

Im Grunde haben wir eine eindeutige Liste von Elementen in der Hash erstellen. Für jedes dieser Elemente haben wir eine „Eigenschaft“ hash, die einen Skalar enthält , countund eine Anordnung für die position. Die Anzahl der Elemente in dem Array soll, variieren basierend auf wie viele Vorkommen des Elements in der ursprünglichen waren.

Die skalare Eigenschaft ist nicht wirklich notwendig , da man immer die skalare des nehmen könnte positionArray die gleiche Nummer abzurufen. Hinweis: Wenn Sie jemals hinzufügen / entfernen Elemente aus dem Array countund positionnicht in ihrer Bedeutung korrelieren.

• Beispiel: print scalar @{$new{za}{position}};geben Sie das gleiche wieprint $new{za}{count};

Gerade realisierte Ihre Frage sagte sie keine vorbestimmten Reihenfolge ist, so dass dies nicht relevent werden kann.

Perl-Code:

$list = [
    ['do', 're', 'fa', 'ti' ],
    ['do', 're', 'mi' ],
    ['do', 'la', 'ti', 'za' ],
    ['mi', 'fa' ],
    ['re', 'so', 'za' ]
];
%sid = map{($_,$n++)}qw/do re mi fa so la ti za/;

map{map{$k{$_}++}@$_}@$list;
push @$result,[$_,$k{$_}] for sort{$sid{$a}<=>$sid{$b}}keys%k;

print "[@$_]\n" for(@$result);

Ausgabe:

[do 3]
[re 3]
[mi 2]
[fa 2]
[so 1]
[la 1]
[ti 2]
[za 2]

Verwenden einer Hash zu aggregieren.

my $notes= [[qw(do re fa ti)],
       [qw(do re mi)],
       [qw(do la ti za)],
       [qw(mi fa)],
       [qw(re so za)]];

my %out;
foreach my $list (@$notes)
{
  $out{$_}++ foreach @$list;
}

print "$_: $out{$_}\n" foreach sort keys %out;

Die Ausbeuten

do: 3
fa: 2
la: 1
mi: 2
re: 3
so: 1
ti: 2
za: 2

Das% aus Hash wird einfach in eine Liste umgewandelt, wenn das ist, was Sie wollen.

my @newout;
push @newout,[$_,$out{$_}] foreach sort keys %out;