假设我们在字符串上有一组特定的函数。这些函数有点像填入空格或madlib，不同之处在于它们仅接受一个输入并使用该输入来填入所有空白。例如，我们可能有一个看起来像

I went to the ____ store and bought ____ today.

如果我们将此功能应用于字符串cheese，结果将是：

I went to the cheese store and bought cheese today.

我们可以将这些函数表示为字符串的非空列表，其中的空格只是字符串之间的空白。例如，我们上面的函数将是：

["I went to the ", " store and bought ", " today."]

在这种表示形式下，此类每种功能只有一种表示形式，而每种表示形式仅一种功能。

一件真正整洁的事情是，这些功能的集合在组合时是封闭的。也就是说，我们两个功能的组合始终是这些功能中的另一个。例如，如果我用

["blue ", ""]

（添加blue到输入的函数）我们得到函数：

["I went to the blue ", " store and bought blue ", " today."]

这些可能会变得更加复杂。例如，如果我们用

["big ", " and ", ""]

结果是

["I went to the big ", " and ", " store and bought big ", "and", " today."]

任务

您的任务是采用描述为字符串的非空列表的两个函数，并将它们的组成作为字符串的非空列表输出。

出于此挑战的目的，列表可以是允许重复的任何有序容器，字符串可以是本机字符串类型，字符列表或整数列表。

这是代码高尔夫球答案，将以字节计分，而字节越少越好。

测试用例

["","xy"] ["ab",""] -> ["ab","xy"]
["x","y","z"] ["a","b"] -> ["xa","bya","bz"]
["xy"] ["ab"] -> ["xy"]
["","",""] ["a",""] -> ["a","a",""]
["x",""] ["","",""] -> ["x","",""]
["x","y","z"] ["a","b","c"] -> ["xa","b","cya","b","cz"]
["x","x","x"] ["a"] -> ["xaxax"]
["w","x","y","z"] ["ab","cd","e"] -> ["wab","cd","exab","cd","eyab","cd","ez"]

果冻，6 个字节

j0j@ṣ0

甲二进链路接受第一对函数表示右和第二对函数表示左其产生所得到的函数表示。每个函数表示形式都是一个字符列表（Jelly没有其他字符串）。

在线尝试！（完整程序参数以Python表示法给出；字符串成为列表。页脚显示了Link输出的Python表示。）

这是一个测试套件，可以像输入一样重新格式化Link的输出。

怎么样？

利用Jelly的混合类型列表，通过使用整数零作为占位符来允许整个表示域（字符列表的任何列表）：

j0j@ṣ0 - Link: b, a        e.g.    b = [['a','b'],['c','d'],['e']]
       -                   ...and  a = [['w'],['x'],['y'],['z']]
                             (i.e. test-case ["w","x","y","z"] ["ab","cd","e"])
j0     - join b with zeros         ['a','b',0,'c','d',0,'e']    
  j@   - join a with that          ['w','a','b',0,'c','d',0,'e','x','a','b',0,'c','d',0,'e','y','a','b',0,'c','d',0,'e','z']
    ṣ0 - split at zeros            [['w','a','b'],['c','d'],['e','x','a','b'],['c','d'],['e','y','a','b'],['c','d'],['e','z']
                             (i.e.: ["wab","cd","exab","cd","eyab","cd","ez"])

如果我们需要处理Jelly的任何混合列表（包括任何深度或形状的列表），我们都可以使用这八个byter：j,©⁹jœṣ®它将成对的参数用作占位符。

Haskell，78个字节

(a:b:r)#t@(x:s)|s>[]=(a++x):init s++((last s++b):r)#t|z<-a++x++b=(z:r)#t
x#_=x

在线尝试！

Python 3.8（预发布）， 60  58字节

lambda a,b:(v:='&'.join(a+b)+'$').join(b).join(a).split(v)

一位不愿具名的函数接受字符串的两个列表，a并且b，它返回一个字符串列表。

在线尝试！或查看测试套件。

怎么样？

首先形成分隔符字符串，v在a或中找不到b。然后通过将字符串b与的副本连接在一起来形成字符串v。然后通过将字符串a与该字符串的副本连接起来来形成字符串。最后在的实例处拆分该字符串v以提供字符串列表。

虽然确保v不在，a否则b我们还必须确保v在in a和in所有字符串b相等的情况下，我们不会早日分裂。为此，我们v将两个列表中的所有字符串与一个字符串的实例连接在一起（此处为'&'），并添加一个额外的不同字符（此处为'$'）。请注意，单独执行任一操作还不够，因为输入中的所有字符串都可以等于所选字符。

05AB1E，4 15 19 9 11 字节

«TýR©ý¹sý®¡

与Jelly的答案不同，05AB1E的string "0"，integer 0和float 0.0都（在某种程度上）相等，所以我不能用整数拆分/连接。这就是为什么我们有+15字节作为解决方法的原因，尽管我现在将其恢复为9字节。感谢@JonathanAllan发现了2个bug。

在线尝试或验证所有测试用例。

说明：

«            # Merge the two (implicit) input-lists together
 Tý          # Then using a "10" delimiter join all strings together
   R         # Reverse this string
    ©        # Store this string in variable `®` (without popping)
     ý       # Use this string as delimiter to join the second (implicit) input-list
      ¹sý    # Then join the first input-list by this entire string
         ®¡  # And split it back on variable `®` so it's the expected list of strings
             # (after which this result is output implicitly)

Wolfram语言（Mathematica），62 61字节

""<>#&/@Flatten[#~(R=Riffle)~I/.I->#2~R~I]~SequenceSplit~{I}&

在线尝试！

-1感谢Roman

尽管它不是有效的输出，但它返回一个实际上完成任务的函数。（34个字节）

(g=a""<>a~Riffle~#&)[#]@*g[#2]&

在线尝试！

Japt，8字节

适应乔纳森的方法。

qVqN²)qN

尝试一下

qVqN²)qN     :Implicit input of arrays U & V (N=[U,V])
q            :Join U with
 Vq          :  V joined with
   N²        :    Push 2 to N (modifying the original), which gets coerced to a string
             >     e.g., N=[["a","b"],["c","d"]] -> N=[["a","b"],["c","d"],2] -> "a,b,c,d,2"
     )       :End join
      qN     :Split on the modified N, which, again, gets coerced to a string
             > e.g., N=[["a","b"],["c","d"],2] -> "a,b,c,d,2"

Haskell，62个字节

[a]#(c:d)=(a++c):d
(a:b)#c=a:b#c
[a]%b=[a]
(a:b)%c=[a]#c#(b%c)

在线尝试！

这是我的Haskell答案。它适用于任何类型的列表。

J，^{44 43 42} 29字节

_<;._1@,(;@}:@,@,.(,_&,)&.>/)

在线尝试！

-13字节感谢英里！

这种方法使用整数，是由于英里。

字符串的原始方法

g=.[:}.@,,.
f=.(<@0<@;;._1@,];@g<"0@[)<@0<@g]

在线尝试！

注意：我已将TIO调整为-3，以说明 f=.

使用Jonathan Allen的方法，适用于J。

这很难打高尔夫球，因为J没有内置的“ join”方法，我很想知道它是否可以显着改善。

g 是使我们“加入”的辅助动词

JavaScript（Node.js），85 79字节

([a,...b],[c,...d])=>b.map(e=>r.push(r.pop(r.push(r.pop()+c,...d))+e),r=[a])&&r

在线尝试！

JavaScript，37个字节

也适应乔纳森的方法。

a=>b=>a.join(b.join(a+=b+0)).split(a)

在线尝试

Perl 5（-lp），20个字节

正如@JonathanAllan所说，这是一个完整的程序，对于IO，使用一个选项卡作为列表分隔符，并使用换行符分隔两个列表。

chop($n=<>);s/  /$n/g

蒂奥

选择选项卡和换行符是因为更方便地检查测试用例，否则可以将其更改为不可打印的字符\1和\2。

（-02l012p）

chop($n=<>);s//$n/g

蒂奥

怎么运行的，

• -02 ：将输入记录分隔符设置为 \2
• -l：从默认参数中删除输入分隔符$_，并将输出记录分隔符添加到默认输出
• -012：将输出记录分隔符设置为\012（\n），以便于检查输出

• -p ：打印默认参数

• $n=<>; ：读取下一条记录并分配给 $n

• chop$n; ：从中删除分隔符 $n
• s/\x1/$n/g：用替换所有出现\1的$n

JavaScript（ES6）， 62  59字节

@Shaggy节省了3个字节

这是Luis答案的固定版本（现已删除），以支持所有字符。

a=>b=>a.map(e=escape).join(b.map(e)).split`,`.map(unescape)

在线尝试！