Чередование редких упорядоченных массивов

Я не совсем уверен, что это будет называться либо, но я нашел способ, чтобы найти порядок заданного массив массивов в качестве входных данных. По существу, псевдо-код:

10 Найти ранний элемент во всех массивах
20 Нажмите , что на список
30 Удалить этот элемент из всех массивов
40 Goto 10 , если есть какие - либо предметы , оставленные

Вот рабочий прототип:

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

Вывод:

, ре, ми, фа, ля, ти, так, З.А.

Решение:

Это решает оригинальный вопрос, прежде чем он был изменен спрашивающего.

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

Как восстановить 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   

В основном, мы создаем уникальный список элементов в хэш. Для каждого из этих элементов у нас есть «свойство» хэш, который содержит скаляр countи массив для position. Количество элементов в массиве должно изменяться в зависимости от того, как много вхождения элемента было в оригинале.

Скалярное свойство не является действительно необходимым , так как вы всегда можете взять скалярный positionмассив , чтобы получить тот же номер. Примечание: если вы когда - нибудь добавить / удалить элементы из массива countи positionне будет коррелировать в их значении.

• Пример: print scalar @{$new{za}{position}};даст вам то же самое,print $new{za}{count};

Просто понял ваш вопрос, сказал, что их не предопределен порядок, так что это не может быть Релевент.

код 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);

вывод:

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

Используйте хэш агрегировать.

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;

Урожайность

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

% Из хэша легко преобразуется в список, если это то, что вы хотите.

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