seyrek sıralanmış diziler Interleaving

Sanırım bu da ne diyeceği gerçekten emin değilim, ancak bir giriş olarak diziler dizi verilen sırasını bulmak için bir yolunu. Esasen sözde kodu:

10 bütün dizilerde en erken öğeyi bulun
listesi üzerine o 20 itin
30 tüm dizilerden o öğeyi kaldırma
kalan herhangi öğeleri olup olmadığını 40 Goto 10

İşte çalışan bir prototip:

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

Çıktı:

do, re, mi, fa, la, ti, bu nedenle, za

Çözüm:

o asker tarafından değiştirildiği önce bu orijinal soruyu çözer.

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

Bilgi Al Nasıl:

   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   

Temelde biz karma elemanların benzersiz bir liste oluşturun. Bu elemanların her biri için bir sayıl içeren bir "özellik" karma var countve bir dizi position. Dizideki elementlerin sayısı elemanının birçok oluşumları orijinal ne kadar göre değişmelidir.

Hep bir skaler sürebilir beri sayıl özellik gerçekten gerekli değildir positionaynı numarayı almak için diziden. Not: Hiç / eklemek diziden öğeleri kaldırmak eğer countve positiononların anlamı korelasyon edilmeyecektir.

• örnek: print scalar @{$new{za}{position}};Size aynı verecekprint $new{za}{count};

Sadece soru hiçbir önceden belirlenmiş düzen onların söyleyen fark, bu nedenle bu Alakalı olmayabilir.

Perl kodu:

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

çıktı:

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

toplamak için bir karma kullanın.

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;

Verim

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

İstediğin buysa karma dışarı% kolayca listeye dönüştürülür.

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