任务：

返回具有数组元素之间所有可能对的数组。

例

从a=["a", "b", "c", "d"];归b=[["a","b"],["a","c"],["a","d"],["b","c"],["b","d"],["c","d"]]。

对可以是任意顺序，只要包括所有可能的组合，并且显然["b","d"]与相同即可["d","b"]。

输入值

由类中的char组成的唯一字符串元素数组[a-z]。

输出量

包含所有可能的输入数组元素对的2d数组。

测试用例

input=["a","b","c"];
//output=[["a","b"],["a","c"],["b","c"]]

input=["a","b","c","d","e"];
//output=[["a","b"],["a","c"],["a","d"],["a","e"],["b","c"],["b","d"],["b","e"],["c","d"],["c","e"],["d","e"]]

注：我找不到一个重复这一挑战。如果有一个，请在评论中提醒我删除问题。

果冻，2个字节

Œc

在线尝试！

Haskell，29个字节

f(a:b)=map((,)a)b++f b
f _=[]

在线尝试！用法示例：f ["a","b","c"]yields [("a","b"),("a","c"),("b","c")]。

使用该标志-XTupleSections可以将其缩短为27个字节，但是该标志需要计数：

f(a:b)=map(a,)b++f b
f _=[]

在线尝试！

Mathematica，14个字节

#~Subsets~{2}&

输入

[{“ a”，“ b”，“ c”}]

Haskell，25个字节

f l=[(x,y)|x<-l,y<-l,x<y]

在线尝试！

外部（x）和内部（y）在输入列表中循环并(x,y)仅在出现时保持该对x < y。

05AB1E，3个字节

码：

æ2ù

使用05AB1E编码。在线尝试！

说明：

æ      # Powerset of the input
 2ù    # Keep the items of length two

vim，50 48

AX<esc>qqYplX@qq@qqrYpllDkxh@rq:g/./norm@r<cr>:g/X/d<cr>dG

以表格形式输入

abcd

并输出为

ad
ac
ab
bd
bc
cd

说明

首先，AX<esc>将a附加X到输入中以处理2长度输入，这是必要的，原因很快就会变得很清楚。

然后是形式的第一个递归宏qq...@qq@q。（记录宏q，在末尾再次运行，结束记录，然后运行一次。）在宏的主体中，Yp复制当前行，l如果该行现在是一个字符长，则跳出宏，然后X删除该行的第一个字符。这产生了最终结果

abcdX
abcX
abX
aX
X
X

X现在忽略s，我们要做的就是abcdX例如将变成ab / ac / ad / aX。这是通过第二个递归宏实现的qr...@rq。

在此宏中，我们首先复制行（Yp），然后通过向右移动两个（ll）并删除至行（D）的末尾，删除除前两个字符以外的所有字符。由于光标现在位于该行kx的第二个字符上，因此将从前一行删除第二个字符，而该字符恰好与该行的第一个字符配对。然后h，由于宏的递归性质，从行（）的开头再次重复此过程，次数必要。

现在，只需在每行上运行宏即可，这可以通过:g/./norm@r（我不确定为什么它的行为不同于:%norm@r，但是可以说，后者不能按预期运行）X来实现:g/X/d。并r清除了由于宏的构建而导致的左端的空行dG。

八度，23字节

@(s)[nchoosek(+s,2) '']

在线尝试！

Python 3，44字节

f=lambda k,*s:[*s]and[[k,x]for x in s]+f(*s)

在线尝试！

将输入作为单独的功能参数。

Brachylog，5个字节

{⊇Ċ}ᶠ

在线尝试！

这个怎么运作

{⊇Ċ}ᶠ
    ᶠ   find all the possible outputs of the following predicate
 ⊇          the output is an ordered subset of the input
  Ċ         the output is a list with two elements

R，18个字节

combn(scan(,''),2)

从stdin读取列表，返回一个矩阵，其中的列为对。

在线尝试！

Python，53个字节

@CalculatorFeline节省了2个字节

lambda a:[(x,y)for i,x in enumerate(a)for y in a[:i]]

在线尝试！

八度， 49 48字节

@(x)[imag(y=(y=triu(x+j*x',1))(~~y)) real(y) '']

避免内置（nchoosek）的匿名函数。

在线尝试！

说明

x+j*x' 使用广播来构建复数矩阵，其中实部和虚部都是来自输入的所有代码点对 x。

y=triu(...,1)保持不包括对角线的上三角部分，使其余元素为零。结果分配给变量y。

y=(...)(~~y) 保留列向量形式的非零元素，该向量被分配给变量 y。

imag(...) 和 real(...)提取实部和虚部。

[... ... ''] 转换回char以构建输出。

Pari / GP，34个字节

a->concat([[[x,y]|y<-a,x<y]|x<-a])

在线尝试！

Python≥2.7，55个字节

lambda l:list(combinations(l,2))
from itertools import*

repl.it！

Perl 6、17个字节

*.combinations(2)

ew，那是一个很长的方法名称。

Scala，17个字节

_.combinations(2)

Pyth，7 4个字节

^{-3个字节，感谢Leaky Nun！}

.cQ2

在线尝试！

红宝石，38 34 24字节

->x{[*x.combination(2)]}

感谢Seims节省了10个字节的想法。

在线尝试！

JavaScript ES6，52个字节

a=>a.map((x,i)=>a.slice(0,i).map(y=>[x,y])).slice(1)

如果有这样的话flatMap，将节省很多字节。

Python，55个字节

f=lambda s:[(s[0],j)for j in s[1:]]+f(s[1:])if s else[]

在线尝试！

比其他Python答案更长，但是它使用了不同的技术，因此我认为值得发布。

Japt，2个字节

à2

测试它（-Q仅用于可视化的标志）

Python，64位元组

f=lambda a:sum((list(zip(a, a[i:]))for i in range(1,len(a))),[])

八度，38字节

@(s)s([[x y]=find(s|s'),y](y<x,[2 1]))

避免nchoosek内置的另一个答案。

在线尝试！

Clojure，42个字节

#(set(for[i % j(remove #{i}%)](set[i j])))

返回一组集合：）

Python，74个字节

f=lambda a:[(c,d) for i,c in enumerate(a) for j,d in enumerate(a) if i<j]

Javascript（ES 5），从108到78字节

我今天发布了答案，但显然我承诺不会接受自己的答案：

x=input;
a=[];

for(n=0;n<(x.length-1);n++){for(i=n+1;i<(x.length);i++){a.push([x[n],x[i]]);}}

J，17个字节

({~$#:I.@,)#\</#\

在线尝试！

说明

({~$#:I.@,)#\</#\  Input: string S
               #\  Get the length of each prefix of S
           #\      Get the length of each prefix of S again
             </    Test using greater than (<) between each
         ,         Flatten
      I.@          Find the indices where the value is 1
   $               Shape of that table
    #:             Convert the indices to the base represented by the shape
 {~                Index into S at those values