Сравнение списков

Вот мое решение:

Создайте хэш, ключи которого представляют собой объединение всех элементов во входных списках, а значения представляют собой битовые строки, где бит я устанавливается, если элемент присутствует в списке я. Битовые строки строятся с использованием побитового или. Затем создайте выходные списки, перебирая ключи хэша, добавляя ключи в связанный выходной список.

sub list_compare {
    my (@lists) = @_;
    my %compare;
    my $bit = 1;
    foreach my $list (@lists) {
        $compare{$_} |= $bit foreach @$list;
        $bit *= 2; # shift over one bit
    }


    my @output_lists;
    foreach my $item (keys %compare) {
        push @{ $output_lists[ $compare{$item} - 1 ] }, $item;
    }

    return \@output_lists;

}

Обновлено, чтобы включить создание перевернутого списка вывода, предложенное Аристотелем.

Прежде всего, хочу отметить, что ответ nohat просто не работает. Попробуйте запустить его и посмотрите на вывод в Data :: Dumper, чтобы убедиться в этом.

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

sub list_compare {
  my @lists = @_;

  my @answers;
  for my $list (@lists) {
    my %in_list = map {$_=>1} @$list;
    # We have this list.
    my @more_answers = [keys %in_list];
    for my $answer (@answers) {
      push @more_answers, [grep $in_list{$_}, @$answer];
    }
    push @answers, @more_answers;
  }

  return @answers;
}

Если вы хотите скорректировать эти предположения, вам нужно будет скорректировать код. Например, не раздавить сложные структуры данных и не раздавить дубликаты можно с помощью:

sub list_compare {
  my @lists = @_;

  my @answers;
  for my $list (@lists) {
    my %in_list = map {$_=>1} @$list;
    # We have this list.
    my @more_answers = [@$list];
    for my $answer (@answers) {
      push @more_answers, [grep $in_list{$_}, @$answer];
    }
    push @answers, @more_answers;
  }

  return @answers;
}

Тем не менее, это использование строковой модификации структуры данных для проверки того, существуют ли вещи, существующие в одной, в другой. Чтобы расслабиться в этом состоянии, потребуется немного больше усилий.

Ваше данное решение можно еще немного упростить.

В первом цикле вы можете использовать простое сложение, поскольку вы всегда выполняете операцию ИЛИ только с отдельными битами, и вы можете сузить область действия $bit, перебирая индексы. Во втором цикле вы можете вычесть 1 из индекса вместо создания ненужного 0-го элемента выходного списка, который необходимо отключить shift, и где вы без необходимости повторяете m * n раз (где m - количество выходных списков, а n - количество уникальных элементов), итерация по уникальным элементам уменьшит количество итераций до n (что является значительным преимуществом в типичных случаях использования, когда m намного больше, чем n), и упростит код.

sub list_compare {
    my ( @list ) = @_;
    my %dest;

    for my $i ( 0 .. $#list ) {
        my $bit = 2**$i;
        $dest{$_} += $bit for @{ $list[ $i ] };
    }

    my @output_list;

    for my $val ( keys %dest ) {
        push @{ $output_list[ $dest{ $val } - 1 ] }, $val;
    }

    return \@output_list;
}

Также обратите внимание, что, если подумать таким образом, процесс сбора результатов может быть очень кратко записан с помощью модуля Список :: Часть:

use List::Part;

sub list_compare {
    my ( @list ) = @_;
    my %dest;

    for my $i ( 0 .. $#list ) {
        my $bit = 2**$i;
        $dest{$_} += $bit for @{ $list[ $i ] };
    }

    return [ part { $dest{ $_ } - 1 } keys %dest ];
}

Но учтите, что list_compare - ужасное имя. Что-то вроде part_elems_by_membership было бы намного лучше. Кроме того, необходимо исправить неточности в вашем вопросе, на которые указал Бен Тилли.