衣衫褴褛

Question

在Haskell (可能还有其他一些语言或其他语言)中，zip是一个函数，它接受两个列表，并通过在同一个索引上配对元素来生成一个元组列表：

zip [1,2,3] [6,5,4] = [(1,6),(2,5),(3,4)]

如果输入列表中有额外的元素，这些元素就会被裁剪掉，并且不会出现在结果中：

zip [1,2,3] [6,5,4,3,2,1] = [(1,6),(2,5),(3,4)]

一个衣衫褴褛的列表就像一个列表，但它不只是包含一种类型的东西，它可以包含两种类型的东西，一种是它本身。例如：

[1,[2,3,[2]]]

这是一个破烂的整数列表。它包含整数和粗糙的整数列表。

你可以很容易地想象拉链衣衫褴褛的名单，其中有一个类似的结构。例如：

zip [1,[2,3,9],3] [2,[3,4,5,6]] = [(1,2),[(2,3),(3,4),(9,5)]]

但是当你必须将一个元素(例如一个整数)和一个结构(例如，一个粗糙的整数列表)组合起来时，事情就变得有点棘手了。为此，我们将在结构中分发元素。下面是一些例子：

zip [1] [[2,3,[5,4]]] = [[(1,2),(1,3),[(1,5),(1,4)]]]
zip [1,2] [3,[4,5]] = [(1,3),[(2,4),(2,5)]]
zip [[2,3],4] [1,[6,7]] = [[(2,1),(3,1)],[(4,6),(4,7)]]

这个Haskell程序可以捕获整个行为：

data Ragged a
  = Ragged (Either a [Ragged a])

zip' :: Ragged a -> Ragged b -> Ragged (a, b)
zip' (Ragged x) (Ragged y) = Ragged $ go x y
  where
    go :: Either a [Ragged a] -> Either b [Ragged b] -> Either (a,b) [Ragged (a,b)]
    go (Left x) (Left y) =
      Left (x, y)
    go (Left x) (Right ys) =
      Right $ (zip' $ Ragged $ Left x) <$> ys
    go (Right xs) (Left y) =
      Right $ (flip zip' $ Ragged $ Left y) <$> xs
    go (Right xs) (Right ys) =
      Right $ zipWith zip' xs ys

在网上试试！

任务

以两个粗糙的正整数列表作为输入，并输出上面定义的zip。输出应该是整数元组的粗糙列表。您可以以任何合理的方式表示粗糙的列表和元组。这里给出的粗糙列表的定义意味着在顶层总是有一个列表，(例如，1不是一个粗糙的整数列表)，所以您可以假设输入是这样的，但是如果更方便的话，您也可以在顶层支持整数。

这是密码-高尔夫，所以目标是最小化源代码的大小(以字节为单位)。

Answer 1

威通，53字节

z=lambda a,b:map(z,[+a]*len(b)?a,[+b]*len(a)?b)?(a,b)

获取两个列表；返回map迭代器而不是列表。在网上试试！

解释

部分灵感来自97.100.97.109‘Python答案。

z=lambda a,b:

将z定义为两个参数a和b的函数。

map(z,...,...)

将z映射到来自以下两个可迭代项的对应项：

[+a]*len(b)?a

如果a是整数，而b是列表，则将a转换为列表，方法是将其放入单个元素列表，然后重复与b长度相等的多次。否则，第一个表达式错误，要么是因为+a是列表时的错误，要么是因为当b是int时，len(b)是错误。在本例中，使用?捕获错误并只使用a。

[+b]*len(a)?b

第二个可迭代性是相同的，但是对于b而不是a。

如果a和b的任一或两者都是列表，则map将获得两个列表作为参数，并将成功。但是，如果它们都是int，则map将获得两个ints作为参数，并将出现错误。因此：

?(a,b)

如果map错误，则返回包含a和b的元组。

Answer 2

K (ngn/k)，58字节

{$[&/i:`i=@:'(x;y);x,'y;|/i;x o'y;o'/#/:/|1(&/#:')\(x;y)]}

在网上试试！

Answer 3

JavaScript，90字节

期望输入类似于z(list1, list2)。支持整数输入

z=(a,b)=>a>z?a.flatMap((x,i)=>b[i]?[z(x,b[i])]:b>z?[]:[z(x,b)]):b>z?b.map(x=>z(a,x)):[a,b]

Ungolfed版本：

z=(a,b)=>{
  if (a>z) return a.flatMap((x,i)=>b[i]?[z(x,b[i])]:b>z?[]:[z(x,b)])
  if (b>z) return b.map(x=>z(a,x))

  return [a,b]
}

试一试：

z=(a,b)=>a>z?a.flatMap((x,i)=>b[i]?[z(x,b[i])]:b>z?[]:[z(x,b)]):b>z?b.map(x=>z(a,x)):[a,b]

;[
  [
    [1, 2], '[1,2]'
  ],
  [
    [1, [2,3]], '[[1,2],[1,3]]'
  ],
  [
    [1, [2,[3]]], '[[1,2],[[1,3]]]'
  ],
  [
    [[2,3], 1], '[[2,1],[3,1]]'
  ],
  [
    [[1,2,3], [4,5,6]], '[[1,4],[2,5],[3,6]]'
  ],
  [
    [[1,2], [4,5,6]], '[[1,4],[2,5]]'
  ],
  [
    [[1,2,3], [4,5]], '[[1,4],[2,5]]'
  ],
  [
    [[1], [[2,3,[4,5]]]], '[[[1,2],[1,3],[[1,4],[1,5]]]]'
  ],
  [
    [[1,2], [3,[4,5]]], '[[1,3],[[2,4],[2,5]]]'
  ],
  [
    [[[1,2],3], [4,[5,6]]], '[[[1,4],[2,4]],[[3,5],[3,6]]]'
  ],
].forEach(([[a,b],c])=>console.log(JSON.stringify(z(a,b)), JSON.stringify(z(a,b)) === c))

UPD 126 -> 98

感谢tsh使提示减少了字节数