Entrelacement tableaux triés rares

Je ne suis pas vraiment sûr de ce que ce serait appelé non plus, mais je me suis un moyen de trouver l'ordre donné le tableau de tableaux en entrée. Essentiellement, le pseudo-code est le suivant:

10 Trouver article premier dans tous les tableaux
20 Poussez sur une liste que
30 Retirer cet élément de tous les tableaux
40 Aller à 10 s'il y a des éléments de gauche

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

Sortie:

do, ré, mi, fa, la, ti, donc, za

Solution:

Cela résout la question initiale avant qu'elle ne soit modifiée par le demandeur.

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

Comment faire pour récupérer 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   

Fondamentalement, nous créons une liste unique d'éléments dans le hachage. Pour chacun de ces éléments que nous avons une table de hachage « propriété », qui contient un scalaire countet un tableau pour la position. Le nombre d'éléments dans le tableau devrait varier, en fonction de combien d'occurrences de l'élément étaient dans l'original.

La propriété scalaire est pas vraiment nécessaire puisque vous pouvez toujours prendre le scalaire du positiontableau pour récupérer le même numéro. Remarque: si jamais vous ajouter / supprimer des éléments du tableau countet positionne seront pas en corrélation dans leur sens.

• exemple: print scalar @{$new{za}{position}};vous donnera la même chose queprint $new{za}{count};

Il suffit de réaliser votre question dit leur est pas d'ordre prédéterminé, donc cela ne peut pas être Relevent.

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

sortie:

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

Utilisez un hachage pour agréger.

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;

Les rendements

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

Le% sur hachage est facilement converti en une liste si c'est ce que vous voulez.

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