Interleaving schaars gesorteerd arrays

Ik ben niet echt zeker wat dit ofwel genoemd zou worden, maar ik bedacht een manier om de volgorde, gezien de reeks van arrays als een ingang vinden. In wezen de pseudo-code is:

10 Zoek vroegste werk in alle arrays
20 Push die op een lijst met
30 Verwijder het item uit alle arrays
40 Goto 10 als er geen items achtergelaten

Hier is een werkend prototype:

#!/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);

Output:

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

Oplossing:

Dit lost het oorspronkelijke vraag voordat het werd gewijzigd door de vraagsteller.

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

Hoe kan ophalen 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   

Kortom, we creëren een unieke lijst van elementen in de hash. Voor elk bestanddeel hebben we een "eigendom" hash, dat een scalair bevat counten een matrix voor position. Het aantal elementen in de array dient te variëren, op basis van het aantal voorkomens van de elementen waren in het origineel.

De scalaire pand is niet echt nodig, omdat je de scalaire van het altijd zou kunnen nemen positionarray naar hetzelfde nummer op te halen. Let op: als je ooit toevoegen / verwijderen van elementen uit de array counten positionwordt niet correleren in hun betekenis.

• Bijvoorbeeld: print scalar @{$new{za}{position}};zal je hetzelfde als gevenprint $new{za}{count};

Net realiseerde uw vraag gezegd hun is geen vooraf bepaalde volgorde, dus dit kan niet worden bestaande reglementen.

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

output:

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

Gebruik een hash te aggregeren.

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;

opbrengsten

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

De% out hash wordt gemakkelijk omgezet in een lijst als dat is wat je wilt.

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