Существует ли элегантный почтовый индекс для чередования двух списков в Perl 5?

Question

Мне недавно «понадобилась» функция zip в Perl 5 (пока я думал о Как рассчитать относительное время? ), то есть функция, которая собирает два списка и объединяет их в один список, чередование элементов.

(псевдо) пример:

@a=(1, 2, 3);
@b=('apple', 'orange', 'grape');
zip @a, @b; # (1, 'apple', 2, 'orange', 3, 'grape');

У Haskell есть zip в Prelude и В Perl 6 встроен оператор zip , но как это сделать элегантно в Perl 5?

Answer 1

Предполагая, что у вас есть ровно два списка и они имеют одинаковую длину, вот решение, изначально предложенное Мерлином (Рэндал Шварц), который назвал его извращенным perlish:

sub zip2 {
    my $p = @_ / 2; 
    return @_[ map { $_, $_ + $p } 0 .. $p - 1 ];
}

Что происходит здесь, так это то, что для списка из 10 элементов сначала мы находим точку поворота в середине, в данном случае 5, и сохраняем ее в $p. Затем мы составляем список индексов до этой точки, в данном случае 0 1 2 3 4. Далее мы используем map для сопряжения каждого индекса с другим индексом, который находится на том же расстоянии от точки поворота, что и первый индекс от начнем, давая нам (в данном случае) 0 5 1 6 2 7 3 8 4 9. Затем мы берем фрагмент из @_, используя его в качестве списка индексов. Это означает, что если 'a', 'b', 'c', 1, 2, 3 передается zip2, он вернет этот список, перестроенный в 'a', 1, 'b', 2, 'c', 3.

Это может быть записано в одном выражении вдоль строк ysth, например:

sub zip2 { @_[map { $_, $_ + @_/2 } 0..(@_/2 - 1)] }

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

Answer 2

Модуль List :: MoreUtils имеет функцию zip / mesh, которая должна выполнить свою задачу:

use List::MoreUtils qw(zip);

my @numbers = (1, 2, 3);
my @fruit = ('apple', 'orange', 'grape');

my @zipped = zip @numbers, @fruit;

Вот источник функции сетки:

sub mesh (\@\@;\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@) {
    my $max = -1;
    $max < $#$_  &&  ($max = $#$_)  for @_;

    map { my $ix = $_; map $_->[$ix], @_; } 0..$max; 
}

Answer 3

Я считаю следующее решение простым и легким для чтения:

@a = (1, 2, 3);
@b = ('apple', 'orange', 'grape');
@zipped = map {($a[$_], $b[$_])} (0 .. $#a);

Я считаю, что это также быстрее, чем решения, которые сначала создают массив в неправильном порядке, а затем используют срез для изменения порядка, или решения, которые изменяют @a и @b.

Answer 4

Для массивов одинаковой длины:

my @zipped = ( @a, @b )[ map { $_, $_ + @a } ( 0 .. $#a ) ];

Answer 5

Algorithm::Loops действительно хорошо, если вы делаете много такого рода вещей.

Мой собственный код:

sub zip { @_[map $_&1 ? $_>>1 : ($_>>1)+($#_>>1), 1..@_] }

Answer 6

my @l1 = qw/1 2 3/;
my @l2 = qw/7 8 9/;
my @out; 
push @out, shift @l1, shift @l2 while ( @l1 || @l2 );

Если списки имеют разную длину, это добавит 'undef' в дополнительные слоты, но вы можете легко исправить это, если не хотите этого делать. Что-то вроде (@ l1 [0] && shift @ l1) сделает это.

Надеюсь, это поможет!

Answer 7

Это совершенно не изящное решение, и при этом это не лучшее решение для любой части воображения. Но это весело!

package zip;

sub TIEARRAY {
    my ($class, @self) = @_;
    bless \@self, $class;
}

sub FETCH {
    my ($self, $index) = @_;
    $self->[$index % @$self][$index / @$self];
}

sub STORE {
    my ($self, $index, $value) = @_;
    $self->[$index % @$self][$index / @$self] = $value;
}

sub FETCHSIZE {
    my ($self) = @_;
    my $size = 0;
    @$_ > $size and $size = @$_ for @$self;
    $size * @$self;
}

sub CLEAR {
    my ($self) = @_;
    @$_ = () for @$self;
}

package main;

my @a = qw(a b c d e f g);
my @b = 1 .. 7;

tie my @c, zip => \@a, \@b;

print "@c\n";  # ==> a 1 b 2 c 3 d 4 e 5 f 6 g 7

Как справиться STORESIZE / PUSH / POP / SHIFT / UNSHIFT / SPLICE - это упражнение, оставленное читателю.