Cartesian product of two lists

Question

Task

Given two lists of characters, output their Cartesian product, i.e. the list of pairings of each letter from the first list with each letter from the second list.

Example

"123456" and "abcd" give:

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

Input

Two lists of characters or strings. The characters used will be alphanumeric a-z, A-Z, 0-9 and a character can occur both multiple times and in both inputs at the same time.

Output

The Cartesian product of the input lists. That is, a list of each possible ordered pair of a character from the first list and a character from the second list. Each pair is a list or string or similar of two characters, or of two length-one strings. The output's length will be equal to the product of the lengths of the inputs.

The pairs must be listed in order; first listing the first character of the first list with the first of the second list, followed by all the pairings of the first character of the first list. The last pair consists of the last character of the first list together with the last character of the second list.

The output must be a flat list of pairs; not a 2D matrix where pairs are grouped by their first or second element.

Test cases

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

Answer 1

05AB1E, 1 byte

â

Try it online!

Answer 2

Haskell, 12 bytes

(<*>).map(,)

Try it online!

Answer 3

Mathematica, 12 bytes

Tuples@{##}&

Takes two lists of characters as input.

Answer 4

APL (Dyalog), 4 bytes

,∘.,

Try it online!

, flatten

∘. the Cartesian

, concatenation

Answer 5

Ruby, 30 18 bytes

-12 bytes from Jordan reminding me of a way to use the spec to my advantage!

Takes lists of characters as input.

->a,b{a.product b}

Try it online!

Answer 6

Perl 6, 4 bytes

&[X]

This is just a reference to the built-in cross product operator X. It works on lists of any sort, not just characters.

Answer 7

Jelly, 1 byte

p

Try it online!

Answer 8

JavaScript (ES6), 45 36 34 33 bytes

Requires Firefox. Takes both inputs as strings or as arrays of individual characters.

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

• -1 byte thanks to CalculatorFeline spotting an errant <space>.

---

Try It

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>

Answer 9

Octave, 32 bytes

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

Try it online!

Answer 10

Tcl, 60 bytes

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

Use:

% 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}

Answer 11

Bash, 18

This can be done with brace expansions:

eval echo {$1}{$2}

Try it online.

Answer 12

Brachylog, 5 bytes

{∋ᵐ}ᶠ

Try it online!

Explanation

Pretty self-explanatory

{  }ᶠ       Find all:
  ᵐ           Map:
 ∋              In

Answer 13

QBIC, 29 bytes

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

This prints 2-char strings with all combinations on one line each.

Explanation

   ;      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

Answer 14

Pyth, 3 bytes

*ww

Multiplying two strings just acts as the cartesian product.

Test it online!

Answer 15

MATL, 2 bytes

Z*

* is the general operator for products and the prefix Z makes it the cartesian product and can take two strings as arguments.

Try it online!

Answer 16

Actually, 1 byte

∙

Try it online!

∙ is the Cartesian product command.

Answer 17

Ohm, 1 byte

╒

Try it online!

Literally only the built-in

Answer 18

J, 3 bytes

,@{

This is the Catalogue verb in J. We need to Ravel (,) the result to make it 1 dimensional.

Try it online!

Answer 19

Common Lisp, 63 bytes

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

Try it online!

Answer 20

Python 2, 39 bytes

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

Try it online!

Alternate solution, 34 30 bytes

-4 bytes thanks to Anders Kaseorg.

There is a built-in for this...

from itertools import*
product

Answer 21

Clojure, 21 bytes

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

Answer 22

C# 7, 78 63 bytes

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

Answer 23

PHP, 69 bytes

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

Try it online!

Answer 24

Cheddar, 52 bytes

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

Try it online!

Answer 25

05AB1E, 10 bytes

v²NFÀ}¹ø)˜

Try it online!

This is without the built-in, and undoubtedly won't be competitive.

Answer 26

Retina, 49 bytes

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

Try it online! Takes input on separate lines. Explanation:

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

Each character in the first string generates a separate line prefixed by the second string.

¶¶.+
¶

The original second string is deleted.

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

For each character in the first string, each character in the second string generates a separate line prefixed with the first character.

¶.¶
¶

The left-over characters from the first string are deleted.

Answer 27

Charcoal, 8 7 bytes

ＦθＥη⁺ικ

Try it online! Link is to verbose version of code. Explanation: The variables θ and η implicitly refer to the two input strings. The Ｆ command loops over each character of the first input, while the Ｅ command maps over each character of the second input concatenating the loop variable ι and the map variable κ, the result of which is implicitly printed on separate lines.

Answer 28

q/kdb+, 5 bytes

Solution:

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

Example:

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

Answer 29

Japt, 5 2 bytes

Japt now has a method for the Cartesian product.

Takes input as 2 arrays of character strings.

ïV

Try it

Answer 30

R, 29 bytes

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

Try it online!

Note that R matrix are filled by column, so the result is in the order dictated by the spec.

If allowed to have factors for input and output, there is a built-in... but one needs to extract the resulting levels from the factor so in the end it would be more than 29 bytes.

R, 11 bytes

interaction

Try it online!

Answer 31

Jq 1.5, 29 bytes

map(split(""))|[combinations]

Uses combinations builtin.

Sample Run

$ jq -Mc  'map(split(""))|[combinations]' <<< '["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"]]

$ echo -n 'map(split(""))|[combinations]' | wc -c
  29

Answer 32

Axiom, 55 bytes

f(a,b)==concat[[[a.x,b.y]for y in 1..#b]for x in 1..#a]

some results

(15) -> f("123456","abcd")
   (15)
   [[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]]
                                                Type: List List Character
(16) -> f("abc","123")
   (16)  [[a,1],[a,2],[a,3],[b,1],[b,2],[b,3],[c,1],[c,2],[c,3]]
                                                Type: List List Character
(17) -> f("aa","aba")
   (17)  [[a,a],[a,b],[a,a],[a,a],[a,b],[a,a]]
                                                Type: List List Character

Answer 33

APL NARS 8 chars

{,⍺∘.,⍵}

Copy from https://codegolf.stackexchange.com/a/125115/58988 test

f←{,⍺∘.,⍵}
'123456' f 'abcd'
 1a 1b 1c 1d 2a 2b 2c 2d 3a 3b 3c 3d 4a 4b 4c 4d 5a 5b 5c 5d 6a 6b 6c 6d 

Answer 34

Prolog (SWI), 48 bytes

L-R:-findall([A,B],(member(A,L),member(B,L)),R).

Try it online!

Answer 35

GolfScript, 21 bytes

~\:a;{a{[.;1$]}%\;}%`

Try it online!