任务

给定两个字符列表，输出其笛卡尔积，即，第一个列表中每个字母与第二个列表中每个字母的配对列表。

例

"123456"并"abcd"给出：

[["1","a"],["1","b"],["1","c"],["1","d"],["2","a"],["2","b"],["2","c"],["2","d"],["3","a"],["3","b"],["3","c"],["3","d"],["4","a"],["4","b"],["4","c"],["4","d"],["5","a"],["5","b"],["5","c"],["5","d"],["6","a"],["6","b"],["6","c"],["6","d"]]

输入值

两个字符或字符串列表。所使用的字符将是字母数字字符，a-z, A-Z, 0-9并且一个字符可以出现两次，并且可以同时出现在两个输入中。

输出量

输入列表的笛卡尔积。即，列出来自第一列表的字符和来自第二列表的字符的每个可能有序对的列表。每对都是两个字符或两个长度为一的字符串的列表或字符串或类似内容。输出的长度将等于输入长度的乘积。

对必须按顺序列出；首先列出第一个列表的第一个字符与第二个列表的第一个，然后是第一个列表的第一个字符的所有配对。最后一对由第一个列表的最后一个字符和第二个列表的最后一个字符组成。

输出必须是对的平面列表；不是2D矩阵，其中按对的第一个或第二个元素进行分组。

测试用例

inputs               output

"123456", "abcd"     [["1","a"],["1","b"],["1","c"],["1","d"],["2","a"],["2","b"],["2","c"],["2","d"],["3","a"],["3","b"],["3","c"],["3","d"],["4","a"],["4","b"],["4","c"],["4","d"],["5","a"],["5","b"],["5","c"],["5","d"],["6","a"],["6","b"],["6","c"],["6","d"]]
"abc", "123"         [["a","1"],["a","2"],["a","3"],["b","1"],["b","2"],["b","3"],["c","1"],["c","2"],["c","3"]]
"aa", "aba"          [["a","a"],["a","b"],["a","a"],["a","a"],["a","b"],["a","a"]]

05AB1E，1个字节

â

在线尝试！

Haskell，12个字节

(<*>).map(,)

在线尝试！

Mathematica，12个字节

Tuples@{##}&

将两个字符列表作为输入。

APL（Dyalog），4个字节

,∘.,

在线尝试！

, 展平

∘. 笛卡尔

, 级联

红宝石，30 18字节

约旦的-12个字节使我想起了使用该规范对我有利的一种方式！

将字符列表作为输入。

->a,b{a.product b}

在线尝试！

Perl 6、4个字节

&[X]

这只是对内置交叉产品运算符的参考X。它适用于任何类型的列表，而不仅仅是字符。

果冻，1字节

p

在线尝试！

八度，32字节

@(a,b)[(a+~b')(:) (b'+~a)(:) '']

在线尝试！

Tcl，60个字节

proc p x\ y {lmap X $x {lmap Y $y {lappend l $X\ $Y}};set l}

用：

% p {1 2 3} {a 2 2}
{1 a} {1 2} {1 2} {2 a} {2 2} {2 2} {3 a} {3 2} {3 2}

JavaScript（ES6），45 36 34 33字节

需要Firefox。将两个输入都当作字符串或单个字符的数组。

a=>b=>[for(x of a)for(y of b)x+y]

• -1个字节，感谢CalculatorFeline发现了一个错误<space>。

尝试一下

f=
a=>b=>[for(x of a)for(y of b)x+y]
oninput=_=>console.clear()&console.log(f(i.value)(j.value))
console.log(f(i.value="123456")(j.value="abcd"))

<input id=i><input id=j>

Bash，18岁

这可以通过大括号扩展来完成：

eval echo {$1}{$2}

在线尝试。

Brachylog，5个字节

{∋ᵐ}ᶠ

在线尝试！

说明

相当不言自明

{  }ᶠ       Find all:
  ᵐ           Map:
 ∋              In

QBIC，29个字节

[_l;||[_l;||?_sA,a,1|+_sB,b,1

这会打印2字符的字符串，所有组合都在一行上。

说明

   ;      Read in string A$
 _l |     Get its length as b
[    |    and kick off a FOR-loop from 1 to that
[_l;||    Do the same for B$
          Note that, while the FOR-loop may pass this code several times, the
          'read-from cmd line' is done only once.
?_sA,a,1| PRINT the character from A$ at the position of the 'a' loop counter
+_sB,a,1   concatenated with the char from B$ at the pos of the 'b' loop counter

Pyth，3个字节

*ww

将两个字符串相乘只是笛卡尔积。

在线测试！

MATL，2个字节

Z*

*是产品的通用运算符，前缀Z使它成为笛卡尔乘积，并且可以接受两个字符串作为参数。

在线尝试！

实际上，是1个字节

∙

在线尝试！

∙ 是笛卡尔乘积命令。

欧姆，1个字节

╒

在线尝试！

从字面上看只有内置

J，3个字节

,@{

这是J中的Catalog动词。我们需要将Ravel（,）的结果设为1维。

在线尝试！

Common Lisp，63个字节

(lambda(a b)(mapcan(lambda(x)(mapcar(lambda(y)(list x y))b))a))

在线尝试！

Clojure，21个字节

#(for[i % j %2][i j])

PHP，69字节

<?foreach($_GET[0]as$x)foreach($_GET[1]as$y)$r[]=[$x,$y];print_r($r);

在线尝试！

Python 2，39个字节

lambda x,y:[[i,j]for i in x for j in y]

在线尝试！

替代解决方案，34 30字节

-4个字节感谢Anders Kaseorg。

有一个内置的...

from itertools import*
product

切达 52字节

a->b->a.chars.map(i->b.chars.map(i&(+))).reduce((+))

在线尝试！

05AB1E，10个字节

v²NFÀ}¹ø)˜

在线尝试！

这是没有内置的，并且毫无竞争力。

视网膜，49字节

.(?=.*¶(.+))
$1$&¶
¶¶.+
¶
.(?=.*(.)¶)
$1$&¶
¶.¶
¶

在线尝试！在单独的行上输入。说明：

.(?=.*¶(.+))
$1$&¶

第一个字符串中的每个字符都会产生一个单独的行，并以第二个字符串为前缀。

¶¶.+
¶

原始的第二个字符串将被删除。

.(?=.*(.)¶)
$1$&¶

对于第一个字符串中的每个字符，第二个字符串中的每个字符都会生成以第一个字符为前缀的单独行。

¶.¶
¶

第一个字符串中剩余的字符将被删除。

q / kdb +，5个字节

解：

cross           / yup, there's a built-in to do exactly this

例：

q)"123456"cross"abcd"
"1a"
"1b"
"1c"
"1d"
"2a"
"2b"
"2c"
"2d"
"3a"
"3b"
"3c"
"3d"
"4a"
"4b"
...etc

木炭，8 7字节

ＦθＥη⁺ικ

在线尝试！链接是详细版本的代码。说明：变量θ和η隐式引用两个输入字符串。该Ｆ命令在第一个输入的每个字符上循环，而该Ｅ命令在第二个输入的每个字符上映射，从而将loop变量ι和map变量连接在一起κ，其结果隐式打印在单独的行上。

R，29个字节

function(x,y)outer(x,y,paste)

在线尝试！

请注意，R矩阵是按列填充的，因此结果是按规范指定的顺序。

如果允许factors输入和输出，则有一个内置的...，但是需要从因子中提取结果级别，因此最终将超过29个字节。

R，11个字节

interaction

在线尝试！

Japt，5 2字节

Japt现在有一种用于笛卡尔积的方法。

将输入作为2个字符串数组。

ïV

尝试一下

C＃7，78 63字节

(a,b)=>$"({string.Join(",",a.SelectMany(x=>b,(x,y)=>(x,y)))})";