All non-ordered pairs between the elements of an array

Question

Task:

Return an array with all possible pairs between the elements of an array.

Example

From a=["a", "b", "c", "d"]; return b=[["a","b"],["a","c"],["a","d"],["b","c"],["b","d"],["c","d"]].

Pairs can be in any order as long as all possible combinations are included and obviously ["b","d"] is the same to ["d","b"].

Input

Array of unique string elements composed of chars from the class [a-z].

Output

2d array containing all the possible pairs of input array's elements.

Test Cases

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"]]

Note: I could not find a duplicate to this challenge. If there is one, alert me with a comment to drop question.

Answer 1

Haskell, 29 bytes

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

Try it online! Example usage: f ["a","b","c"] yields [("a","b"),("a","c"),("b","c")].

---

With the flag -XTupleSections this can be shortened to 27 bytes, however the flag would need to be counted:

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

Try it online!

Answer 2

Mathematica, 14 bytes

#~Subsets~{2}&

input

[{"a", "b", "c"}]

Answer 3

Haskell, 25 bytes

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

Try it online!

Outer (x) and inner (y) loop through the input list and keep the pair (x,y) only if x < y.

Answer 4

vim, 50 48

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

Takes input in the form

abcd

and outputs as

ad
ac
ab
bd
bc
cd

Explanation

First, AX<esc> appends an X to the input in order to handle 2-length input, which is necessary for reasons that will become clear shortly.

Then comes the first recursive macro, of the form qq...@qq@q. (Record macro q, run itself again at the end, end the recording, then run itself once.) In the body of the macro, Yp duplicates the current line, l breaks out of the macro if the line is now one character long, and X deletes the first character in the line. This has the end result of producing

abcdX
abcX
abX
aX
X
X

Ignoring the Xs for now, all we have to do is turn abcdX, for example, into ab / ac / ad / aX. This is achieved with the second recursive macro, qr...@rq.

In this macro, we first duplicate the line (Yp), then delete everything but the first two characters by moving right two (ll) and deleting to the end of the line (D). Since the cursor is now on the second charcater of the line, kx will delete the second character from the previous line, which happens to be the one that was just paired with the first character on the line. This process is then repeated starting again from the beginning of the line (h) as many times as necessary due to the recursive nature of the macro.

It's now just a matter of running the macro on every line, which can be achieved with :g/./norm@r (I'm not sure why this behaves differently than :%norm@r, but suffice to say, the latter does not work as intended.) Lines with X are deleted with :g/X/d, and the blank lines at the end left as a result of the construction of the r macro are cleaned up with dG.

Answer 5

Brachylog, 5 bytes

{⊇Ċ}ᶠ

Try it online!

How it works

{⊇Ċ}ᶠ
    ᶠ   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

Answer 6

Jelly, 2 bytes

Œc

Try it online!

Answer 7

05AB1E, 3 bytes

Code:

æ2ù

Uses the 05AB1E encoding. Try it online!

Explanation:

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

Answer 8

Octave, 23 bytes

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

Try it online!

Answer 9

Python 3, 44 bytes

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

Try it online!

Takes input as individual function parameters.

Answer 10

Octave, 49 48 bytes

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

Anonymous function that avoids the built-in (nchoosek).

Try it online!

Explanation

x+j*x' uses broadcasting to build a matrix of complex numbers where the real and imaginary parts are all pairs of code points from the input x.

y=triu(...,1) keeps the upper triangular part excluding the diagonal, making the rest of elements zero. The result is assigned to variable y.

y=(...)(~~y) retains the nonzero elements in the form of a column vector, which is assigned to variable y.

imag(...) and real(...) extract the real and imaginary parts.

[... ... ''] converts back to char to build the output.

Answer 11

R, 18 bytes

combn(scan(,''),2)

reads the list from stdin, returns a matrix where the columns are pairs.

Try it online!

Answer 12

Python, 53 bytes

2 bytes saved thanks to @CalculatorFeline

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

Try it online!

Answer 13

Perl 6, 17 bytes

*.combinations(2)

Whew, that's a long method name.

Answer 14

Pari/GP, 34 bytes

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

Try it online!

Answer 15

Octave, 38 bytes

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

Another answer to avoid nchoosek built-in.

Try it online!

Answer 16

Arturo, 18 bytes

$=>[combine.by:2&]

Try it

Answer 17

Python ≥ 2.7, 55 bytes

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

repl.it!

Answer 18

Scala, 17 bytes

_.combinations(2)

Answer 19

Pyth, 7 4 bytes

^{-3 bytes thanks to Leaky Nun!}

.cQ2

Try it online!

Answer 20

Japt, 2 bytes

à2

Test it (-Q flag for visualisation purposes only)

Answer 21

Python, 64 bytes

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

Answer 22

Clojure, 42 bytes

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

Returns a set of sets :)

Answer 23

Python, 74 bytes

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

Answer 24

Ruby, 38 34 24 bytes

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

Thanks Seims for the idea that saved 10 bytes.

Try it online!

Answer 25

Javascript (ES 5), from 108 to 78 bytes

I post my answer today but I obviously promise to not accept my own answer:

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]]);}}

Answer 26

J, 17 bytes

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

Try it online!

Explanation

({~$#: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

Answer 27

Pip, -p 4 bytes

aCB2

CB is the operator for combinations, not much explanation needed

Try It Online!

Answer 28

Go, 132 bytes

func f[T any](S[]T)(O[][]T){if len(S)<3{O=append(O,S)}else{for a,i:=range(S){for _,j:=range(S[a+1:]){O=append(O,[]T{i,j})}}}
return}

Attempt This Online!

A generic function that takes in a slice of type T and outputs a slice of slices of type T.

A solution that does only []string -> [][]string is 8 bytes longer.

Explanation

func f[T any](S[]T)(O[][]T){  // boilerplate
if len(S)<3{                  // if the input length < 3,
  O=append(O,S)               // just return the input
}else{                        // otherwise,
  for a,i:=range(S){          // for each 1st element,
    for _,j:=range(S[a+1:]){  // and each 2nd element,
      O=append(O,[]T{i,j})}}} // add the pair
return}                       // return the result

Answer 29

JavaScript ES6, 52 bytes

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

If there was like a flatMap that would save a lot of bytes.

Answer 30

Python, 55 bytes

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

Try it online!

Longer than other Python answers, but it uses a different technique so I think it's worth posting.