Intercalarea matrice sortate rare

Nu sunt foarte sigur ce acest lucru ar fi numit, fie, dar am dat seama o modalitate de a găsi ordinea dată matrice de matrice ca o intrare. În esență, pseudo-cod este:

10 Găsiți mai devreme element în toate matricele
20 Push că pe o listă de
30 Eliminați elementul din toate matricele
40 Du - te la 10 în cazul în care există elemente rămase

Iată un prototip de lucru:

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

ieşire:

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

Soluţie:

Aceasta rezolvă întrebarea inițială înainte de a fi fost modificat de Autorul întrebării.

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

Cum de a prelua informații:

   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   

Practic, vom crea o listă unică de elemente hash. Pentru fiecare dintre aceste elemente avem o „proprietate“ hash, care conține un scalar countși o matrice pentru position. Numărul de elemente din matrice ar trebui să varieze, în funcție de cât de multe apariții ale elementului au fost în original.

Proprietatea scalară nu este cu adevărat necesar , deoarece ai putea lua întotdeauna scalar de positionmatrice pentru a prelua același număr. Notă: dacă adăugați vreodată / elimina elemente din matrice countși positionnu vor fi coreleze în sensul lor.

• exemplu: print scalar @{$new{za}{position}};vă va da la fel caprint $new{za}{count};

Doar dat seama întrebarea ta a spus lor este nici o ordine prestabilită, astfel încât aceasta să nu fie sunt relevante.

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

ieșire:

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

Utilizați un hash pentru agregare.

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;

Yield-urile

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

% Din hash este ușor de transformat într-o listă în cazul în care este ceea ce vrei.

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