Przeplatanie rozrzedzone posortowane tablice

Nie jestem pewien, co by to nazwać obaj, ale wymyśliliśmy sposób na znalezienie zlecenia daną tablicę tablic jako wejście. W istocie pseudo-kod jest:

10 Znajdź najwcześniejszą pozycję we wszystkich tablicach
20 Naciśnij że na listę
30 Usuń ten element ze wszystkich tablic
40 Goto 10 Jeśli istnieją jakiekolwiek przedmioty pozostawione

Oto 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);

Wydajność:

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

Rozwiązanie:

To rozwiązuje oryginalne pytanie, zanim została zmodyfikowana przez pytającego.

#!/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 
      }      
   } 

Jak pobrać 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   

Zasadniczo możemy stworzyć niepowtarzalny listę elementów w hash. Dla każdego z tych elementów mamy „właściwość” hash, który zawiera skalarne counti tablicę dla position. Liczba elementów w tablicy powinien się zmieniać, na podstawie ilu wystąpień elementu były w oryginale.

Nieruchomość skalarne nie jest naprawdę konieczne, ponieważ zawsze można wziąć skalara na positiontablicy, aby pobrać ten sam numer. Uwaga: jeśli kiedykolwiek dodać / usunąć elementy z tablicy counti positionnie będzie korelować z ich znaczeniem.

• Przykład: print scalar @{$new{za}{position}};daje takie same jakprint $new{za}{count};

Wystarczy sobie sprawę, że ich na Twoje pytanie nie jest z góry ustalony porządek, więc to nie może być dowiemy się z.

Kod Perl:

$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);

wydajność:

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

Użyj skrótu do agregacji.

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;

plony

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

Wartość% hash się łatwo przekształcić w listy, jeśli to, co chcesz.

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