Cartesian product of two or more lists: Difference between revisions

 

<br>

=={{header|11l}}==

{{trans|Go}}

V p = [(0, 0)] * (a.len * b.len)

V i = 0

[Int] empty_array

print(cart_prod([1, 2], empty_array))

====Alternative version====

{{out}}

<pre>

[]

[]

</pre>

 

a matrix, and the task is asking for a list, you also need to ravel the result.

 

 

{{out}}

list of lists.

 

 

{{out}}

 

=={{header|AppleScript}}==

 

-- Two lists:

on unlines(xs)

intercalate(linefeed, xs)

{{Out}}

<pre>[[1, 3], [1, 4], [2, 3], [2, 4]]

 

[]</pre>

 

=={{header|Bracmat}}==

= R a b A B

. :?R

& out$(cartprod$((.1 2 3) (.30) (.500 100)))

& out$(cartprod$((.1 2 3) (.) (.500 100)))

<pre>. (.1776 7 4 0)

(.1776 7 4 1)

(.3 30 100)

.</pre>

 

=={{header|C}}==

Recursive implementation for computing the Cartesian product of lists. In the pursuit of making it as interactive as possible, the parsing function ended up taking the most space. The product set expression must be supplied enclosed by double quotes. Prints out usage on incorrect invocation.

#include<string.h>

#include<stdlib.h>

return 0;

}

Invocation and output :

<pre>

{}

</pre>

public class Program

{

select acc.Concat(new [] { item }));

}

{{out}}

<pre>

{}</pre>

If the number of lists is known, LINQ provides an easier solution:

{

///...

select (a, b, c);

Console.WriteLine($"{{{string.Join(", ", cart2)}}}");

{{out}}

<pre>

{(1, 30, 500), (1, 30, 100), (2, 30, 500), (2, 30, 100), (3, 30, 500), (3, 30, 100)}

</pre>

=={{header|C++}}==

#include <iostream>

#include <vector>

std::cin.get();

return 0;

 

{{out}}

{ (1 30 500) (1 30 100) (2 30 500) (2 30 100) (3 30 500) (3 30 100) }

{ }</pre>

=={{header|Clojure}}==

(ns clojure.examples.product

(:gen-class)

x (first colls)]

(cons x more))))

'''Output'''

(doseq [lst [ [[1,2],[3,4]],

[[3,4],[1,2]], [[], [1, 2]],

(println lst "=>")

(pp/pprint (cart lst)))

 

<pre>

()

</pre>

=={{header|Common Lisp}}==

"Compute the cartesian product of two sets represented as lists"

(loop for x in s1

nconc (loop for y in s2 collect (list x y))))

 

'''Output'''

 

CL-USER> (cartesian-product '(1 2) '(3 4))

((1 3) (1 4) (2 3) (2 4))

CL-USER> (cartesian-product '() '(1 2))

NIL

 

'''Extra credit:'''

 

"Compute the n-cartesian product of a list of sets (each of them represented as list).

Algorithm:

(loop for x in (car l)

nconc (loop for y in (n-cartesian-product (cdr l))

 

'''Output:'''

 

((1776 7 4 0) (1776 7 4 1) (1776 7 14 0) (1776 7 14 1) (1776 7 23 0) (1776 7 23 1) (1776 12 4 0) (1776 12 4 1) (1776 12 14 0) (1776 12 14 1) (1776 12 23 0) (1776 12 23 1) (1789 7 4 0) (1789 7 4 1) (1789 7 14 0) (1789 7 14 1) (1789 7 23 0) (1789 7 23 1) (1789 12 4 0) (1789 12 4 1) (1789 12 14 0) (1789 12 14 1) (1789 12 23 0) (1789 12 23 1))

CL-USER> (n-cartesian-product '((1 2 3) (30) (500 100)))

CL-USER> (n-cartesian-product '((1 2 3) () (500 100)))

NIL

=={{header|Crystal}}==

The first function is the basic task. The version overloaded for one argument is the extra credit task, implemented using recursion.

return a.flat_map { |i| b.map { |j| [i, j] } }

end

puts ""

}

 

{{out}}

[[1776, 7, 4, 0], [1776, 7, 4, 1], [1776, 7, 14, 0], [1776, 7, 14, 1], [1776, 7, 23, 0], [1776, 7, 23, 1], [1776, 12, 4, 0], [1776, 12, 4, 1], [1776, 12, 14, 0], [1776, 12, 14, 1], [1776, 12, 23, 0], [1776, 12, 23, 1], [1789, 7, 4, 0], [1789, 7, 4, 1], [1789, 7, 14, 0], [1789, 7, 14, 1], [1789, 7, 23, 0], [1789, 7, 23, 1], [1789, 12, 4, 0], [1789, 12, 4, 1], [1789, 12, 14, 0], [1789, 12, 14, 1], [1789, 12, 23, 0], [1789, 12, 23, 1]]

</pre>

=={{header|D}}==

 

void main() {

 

return Result();

 

{{out}}

[]

[]</pre>

 

=={{header|F Sharp|F#}}==

===The Task===

//Nigel Galloway February 12th., 2018

let cP2 n g = List.map (fun (n,g)->[n;g]) (List.allPairs n g)

{{out}}

<pre>

 

===Extra Credit===

//Nigel Galloway August 14th., 2018

let cP ng=Seq.foldBack(fun n g->[for n' in n do for g' in g do yield n'::g']) ng [[]]

{{out}}

<pre>

 

=={{header|Factor}}==

{ { { 1 3 } { 1 4 } } { { 2 3 } { 2 4 } } }

IN: scratchpad { 3 4 } { 1 2 } cartesian-product .

{ { } { } }

IN: scratchpad { } { 1 2 } cartesian-product .

 

=={{header|FreeBASIC}}==

I'll leave the extra credit part for someone else. It's just going to amount to repeatedly finding Cartesian products and [[Flatten a list|flattening]] the result, so considerably less interesting than Cartesian products where the list items themselves can be lists.

 

 

type listitem ' An item of a list may be a number

R = cartprod(B, A) : print_list(R) : print

R = cartprod(A, EMPTY) : print_list(R) : print

{{out}}<pre>{{1, 3}, {1, 4}, {2, 3}, {2, 4}}

{{3, 1}, {3, 2}, {4, 1}, {4, 2}}

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

'''Basic Task'''

 

import "fmt"

fmt.Println(cart2([]int{1, 2}, nil))

fmt.Println(cart2(nil, []int{1, 2}))

{{out}}

<pre>

 

This solution minimizes allocations and computes and fills the result sequentially.

 

import "fmt"

fmt.Println(cartN(nil))

fmt.Println(cartN())

{{out}}

<pre>

 

Code here is more compact, but with the cost of more garbage produced. It produces the same result as cartN above.

if len(a) == 0 {

return [][]int{nil}

}

return

'''Extra credit 3'''

 

This is a compact recursive version like Extra credit 2 but the result list is ordered differently. This is still a correct result if you consider a cartesian product to be a set, which is an unordered collection. Note that the set elements are still ordered lists. A cartesian product is an unordered collection of ordered collections. It draws attention though to the gloss of using list representations as sets. Any of the functions here will accept duplicate elements in the input lists, and then produce duplicate elements in the result.

if len(a) == 0 {

return [][]int{nil}

}

return

=={{header|Groovy}}==

'''Solution:'''<br>

The following ''CartesianCategory'' class allows for modification of regular ''Iterable'' interface behavior, overloading ''Iterable'''s ''multiply'' (*) operator to perform a Cartesian Product when the second operand is also an ''Iterable''.

static Iterable multiply(Iterable a, Iterable b) {

assert [a,b].every { it != null }

(0..<(m*n)).inject([]) { prod, i -> prod << [a[i.intdiv(n)], b[i%n]].flatten() }

}

'''Test:'''<br>

The ''mixin'' method call is necessary to make the multiply (*) operator work.

 

println "\nCore Solution:"

println "[John,Paul,George,Ringo] × [Emerson,Lake,Palmer] × [Simon,Garfunkle] = ["

( ["John","Paul","George","Ringo"] * ["Emerson","Lake","Palmer"] * ["Simon","Garfunkle"] ).each { println "\t${it}," }

'''Output:'''

<pre>

[Ringo, Palmer, Garfunkle],

]</pre>

=={{header|Haskell}}==

Various routes can be taken to Cartesian products in Haskell.

For the product of two lists we could write:

cartProd xs ys =

[ (x, y)

| x <- xs

 

more directly:

 

applicatively:

 

parsimoniously:

 

We might test any of these with:

main =

mapM_ print $

uncurry cartProd <$>

{{Out}}

<pre>[(1,3),(1,4),(2,3),(2,4)]

 

For the n-ary Cartesian product of an arbitrary number of lists, we could apply the Prelude's standard '''sequence''' function to a list of lists,

cartProdN = sequence

 

main :: IO ()

{{Out}}

<pre>[[1,3,5],[1,3,6],[1,4,5],[1,4,6],[2,3,5],[2,3,6],[2,4,5],[2,4,6]]</pre>

 

or we could define ourselves an equivalent function over a list of lists in terms of a fold, for example as:

or, equivalently, as:

cartProdN = foldr

(\xs as ->

| x <- xs

, a <- as ])

testing any of these with something like:

main = do

mapM_ print $

print $ cartProdN [[1,2,3], [30], [500, 100]]

putStrLn ""

{{Out}}

<pre>[1776,7,4,0]

 

[]</pre>

=={{header|J}}==

The J primitive [http://code.jsoftware.com/wiki/Vocabulary/curlylf catalogue] <code>{</code> forms the Cartesian Product of two or more boxed lists. The result is a multi-dimensional array (which can be reshaped to a simple list of lists if desired).

┌────────────┬────────────┐

│1776 7 4 0 │1776 7 4 1 │

└───────┴────────┘

{ 1 2 3 ; '' ; 50 100 NB. result is an empty 3-dimensional array with shape 3 0 2

=={{header|Java}}==

{{works with|Java Virtual Machine|1.8}}

import static java.util.Arrays.asList;

import static java.util.Collections.emptyList;

}

}

 

'''Using a generic class with a recursive function'''

import java.util.ArrayList;

import java.util.Arrays;

}

}

=={{header|JavaScript}}==

===ES6===

====Functional====

 

For the Cartesian product of just two lists:

// CARTESIAN PRODUCT OF TWO LISTS ---------------------

 

cartProd([])([1, 2]),

].map(JSON.stringify).join('\n');

{{Out}}

<pre>[[1,3],[1,4],[2,3],[2,4]]

 

Abstracting a little more, we can define the cartesian product quite economically in terms of a general applicative operator:

 

// CARTESIAN PRODUCT OF TWO LISTS ---------------------

.map(JSON.stringify)

.join('\n');

{{Out}}

<pre>[[1,3],[1,4],[2,3],[2,4]]

 

For the n-ary Cartesian product over a list of lists:

const main = () => {

// n-ary Cartesian product of a list of lists.

 

return main();

{{Out}}

<pre>[1776,7,4,0]

Imperative implementations of Cartesian products are inevitably less compact and direct, but we can certainly write an iterative translation of a fold over nested applications of '''bind''' or '''concatMap''':

 

// n-ary Cartesian product of a list of lists

// ( Imperative implementation )

]))

]);

{{Out}}

<pre>[[1,4],[1,3],[2,4],[2,3]]

 

jq is stream-oriented and so we begin by defining a function that will emit a stream of the elements of the Cartesian product of two arrays:

def products: .[0][] as $x | .[1][] as $y | [$x,$y];

 

To generate an array of these arrays, one would in practice most likely simply write `[products]`, but to comply with the requirements of this article, we can define `product` as:

def product: [products];

 

For the sake of brevity, two illustrations should suffice:

 

And

[[1,2], []] | product

produces:

<pre>

Given an array of two or more arrays as input, `cartesians` as defined here produces a stream of the components of their Cartesian product:

 

def cartesians:

if length <= 2 then products

| [$x] + $y

end;

 

Again for brevity, in the following, we will just show the number of items in the Cartesian products:

[[1, 2, 3], [], [500, 100] ] | [cartesians] | length

# 0

=={{header|Julia}}==

Run in REPL.

# Product {1, 2} × {3, 4}

collect(Iterators.product([1, 2], [3, 4]))

# Product {1, 2, 3} × {} × {500, 100}

collect(Iterators.product([1, 2, 3], [], [500, 100]))

=={{header|Kotlin}}==

 

fun flattenList(nestList: List<Any>): List<Any> {

printNAryProduct(listOf(listOf(1, 2, 3), listOf<Int>(), listOf(500, 100)))

printNAryProduct(listOf(listOf(1, 2, 3), listOf(30), listOf('a', 'b')))

 

{{out}}

]

</pre>

=={{header|langur}}==

 

writeln()

 

writeln()

 

writeln()

 

 

{{out}}

=== Functional ===

An iterator is created to output the product items.

local getn = function(t)return #t end

local const = function(k)return function(e) return k end end

print(i,a,b)

end

{{out}}

<pre>1 1 3

 

It is possible that specialising descend by depth may yield a further improvement in performance, but it would only be able to eliminate the lookup of ''sets[depth]'' and the if test, because the reference to ''result[depth]'' is required; I doubt the increase in complexity would be worth the (potential) improvement in performance.

local result = {}

local set_count = #sets

print(" " .. format_nested_list(product))

end

 

=== Imperative iterator ===

The functional implementation restated as an imperative iterator, also adjusted to not allocate a new result table on each iteration; this saves time, but makes mutating the returned table unsafe.

local item_counts = {}

local indices = {}

print(i, format_nested_list(product))

end

 

=={{header|Maple}}==

cartmulti := proc ()

local m, v;

end if;

end proc;

 

 

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

ReadChar

=={{header|Nim}}==

===Task: product of two lists===

In order to display the result using mathematical formalism, we have created a special procedure “$$” for the sequences and have overloaded the procedure “$” for tuples.

 

# Yield the element of the cartesian product of "a" and "b".

# Yield tuples rather than arrays as it allows T1 and T2 to be different.

( Empty, @[1, 2])]:

 

 

{{out}}

Note that there exists in the standard module “algorithm” a procedure which computes the product of sequences of a same type. It is not recursive and, so, likely more efficient that the following version.

 

## Return the product of several sets (sequences).

 

b = @[3, 4]

c = @[5, 6]

 

{{out}}

With a macro, we are able to mix several value types: the “varrags” is no longer a problem as being used at compile time it may contain sequences of different types. And we are able to return tuples of n values instead of sequences of n values.

 

 

macro product(args: varargs[typed]): untyped =

var b = @['a', 'b']

var c = @[false, true]

 

{{out}}

<pre>{1, 2} x {a, b} x {false, true} = {(1, a, false], (1, a, true], (1, b, false], (1, b, true], (2, a, false], (2, a, true], (2, b, false], (2, b, true]}</pre>

=={{header|OCaml}}==

''The double semicolons are necessary only for the toplevel''

 

match l1, l2 with

| [], _ | _, [] -> []

(*- : (int * 'a) list = []*)

product [] [1;2];;

 

Implementation with a bit more tail-call optimization, introducing a helper function. The order of the result is changed but it should not be an issue for most uses.

let rec aux ~acc l1' l2' =

match l1', l2' with

(*- : (int * 'a) list = []*)

product' [] [1;2];;

Implemented using nested folds:

List.fold_left (fun acc1 ele1 ->

List.fold_left (fun acc2 ele2 -> (ele1,ele2)::acc2) acc1 l2) [] l1 ;;

(*- : (int * char) list = [(3, 'c'); (3, 'b'); (3, 'a'); (2, 'c'); (2, 'b'); (2, 'a'); (1, 'c'); (1, 'b'); (1, 'a')]*)

cart_prod [1; 2; 3] [] ;;

 

Extra credit function. Since in OCaml a function can return only one type, and because tuples of different arities are different types, this returns a list of lists rather than a list of tuples. Since lists are homogeneous this version is restricted to products over a ''single'' type, eg integers.

(* We need to do the cross product of our current list and all the others

* so we define a helper function for that *)

*)

product'' [[1; 2; 3];[];[500; 100]];;

 

=== Better type ===

 

In the latter example, our function has this signature:

This lacks clarity as those two lists are not equivalent since one replaces a tuple. We can get a better signature by creating a tuple type:

 

let rec product'' (l:'a list tuple) =

 

type 'a tuple = 'a list

=={{header|Perl}}==

==== Iterative ====

Nested loops, with a short-circuit to quit early if any term is an empty set.

my $sets = shift @_;

for (@$sets) { return [] unless @$_ }

product([[1,2,3], [30], [500,100] ], '%1d %1d %3d' ).

product([[1,2,3], [], [500,100] ], '%1d %1d %3d' ).

{{out}}

<pre>(1 3) (1 4) (2 3) (2 4)

==== Glob ====

This being Perl, there's more than one way to do it. A quick demonstration of how <code>glob</code>, more typically used for filename wildcard expansion, can solve the task.

 

{{out}}

<pre>(1 30 500) (1 30 100) (2 30 500) (2 30 100) (3 30 500) (3 30 100)</pre>

==== Modules ====

A variety of modules can do this correctly for an arbitrary number of lists (each of independent length). Arguably using modules is very idiomatic Perl.

forsetproduct { say "@_" } [1,2,3],[qw/a b c/],[qw/@ $ !/];

 

 

use Algorithm::Loops qw/NestedLoops/;

=={{header|Phix}}==

{{out}}

<pre>

{}

</pre>

=={{header|Phixmonti}}==

 

def cart

 

( ( 1 2 ) ( ) ) cart

=={{header|PicoLisp}}==

(mapcan

'((I)

(cartesian (1 2 3) (30) (500 100)) )

(println

 

{{out}}

((1 30 500) (1 30 100) (2 30 500) (2 30 100) (3 30 500) (3 30 100))

NIL</pre>

=={{header|Prolog}}==

product([A|_], Bs, [A, B]) :- member(B, Bs).

product([_|As], Bs, X) :- product(As, Bs, X).

{{Out}}

<pre>

=={{header|Python}}==

===Using itertools===

 

def cp(lsts):

print(lists, '=>')

pp(cp(lists), indent=2)

{{out}}

<pre>[[1, 2], [3, 4]] =>

If we write ourselves a re-usable Python '''ap''' function for the case of lists (applicative functions for other 'data containers' can also be written – this one applies a list of functions to a list of values):

 

def ap(fs):

return lambda xs: foldl(

lambda a: lambda f: a + foldl(

lambda a: lambda x: a + [f(x)])([])(xs)

 

then one simple use of it will be to define the cartesian product of two lists (of possibly different type) as:

 

 

where Tuple is a constructor, and xs is bound to the first of two lists. The returned value is a function which can be applied to a second list.

For an nAry product, we can then use a '''fold''' (catamorphism) to lift the basic function over two lists ''cartesianProduct :: [a] -> [b] -> [(a, b)]'' to a function over a list of lists:

 

def nAryCartProd(xxs):

return foldl1(cartesianProduct)(

xxs

 

For example:

 

 

 

# TEST ----------------------------------------------------

if __name__ == '__main__':

{{Out}}

<pre>Product of two lists of different types:

[(1, 30, 500), (1, 30, 100), (2, 30, 500), (2, 30, 100), (3, 30, 500), (3, 30, 100)]

[]</pre>

 

=={{header|R}}==

 

one_w_many <- function(one, many) lapply(many, function(x) c(one,x))

 

prod = Reduce( '%p%', list(...) )

display_prod( prod ) }

 

Simple tests:

 

> display_prod( c(1, 2) %p% c(3, 4) )

1, 3

> display_prod( c(3, 4) %p% c() )

>

 

Tougher tests:

 

go( c(1776, 1789), c(7, 12), c(4, 14, 23), c(0, 1) )

go( c(1, 2, 3), c(30), c(500, 100) )

go( c(1, 2, 3), c(), c(500, 100) )

 

{{out}}

(1, 2, 3) * () * (500, 100)

</pre>

=={{header|Racket}}==

 

Racket has a built-in "cartesian-product" function:

 

(require rackunit

;; usually, included in "racket", but we're using racket/base so we

(cartesian-product '(1776 1789) '(7 12) '(4 14 23) '(0 1))

(cartesian-product '(1 2 3) '(30) '(500 100))

 

{{out}}

'((1 30 500) (1 30 100) (2 30 500) (2 30 100) (3 30 500) (3 30 100))

'()</pre>

=={{header|Raku}}==

(formerly Perl 6)

The cross meta operator X will return the cartesian product of two lists. To apply the cross meta-operator to a variable number of lists, use the reduce cross meta operator [X].

 

say (1, 2) X (3, 4);

say (3, 4) X (1, 2);

say [X] (1776, 1789), (7, 12), (4, 14, 23), (0, 1);

say [X] (1, 2, 3), (30), (500, 100);

{{out}}

<pre>((1 3) (1 4) (2 3) (2 4))

((1 30 500) (1 30 100) (2 30 500) (2 30 100) (3 30 500) (3 30 100))

()</pre>

=={{header|REXX}}==

===version 1===

This REXX version isn't limited by the number of lists or the number of sets within a list.

@.= /*assign the default value to @. array*/

parse arg @.1 /*obtain the optional value of @.1 */

end /*i*/

say 'Cartesian product of ' space(@.n) " is ───► {"substr($, 2)'}'

{{out|output|text=&nbsp; when using the default lists:}}

<pre>

 

===version 2===

Call cart '{1, 2} x {3, 4}'

Call cart '{3, 4} x {1, 2}'

End

Say ' '

{{out}}

<pre>{1, 2} x {3, 4}

{1, 2, 3} x {} x {500, 100}

{}</pre>

=={{header|Ring}}==

# Project : Cartesian product of two or more lists

 

next

see nl

Output:

<pre>

(4, 1)

(4, 2)

</pre>

 

=={{header|Ruby}}==

"product" is a method of arrays. It takes one or more arrays as argument and results in the Cartesian product:

p [3, 4].product([1, 2])

p [1, 2].product([])

p [1, 2, 3].product([30], [500, 100])

p [1, 2, 3].product([], [500, 100])

{{out}}<pre>[[1, 3], [1, 4], [2, 3], [2, 4]]

[[3, 1], [3, 2], [4, 1], [4, 2]]

 

=={{header|Rust}}==

let mut res = vec![];

 

}

}

{{out}}<pre>[1, 2] × [3, 4]

[[1, 3], [1, 4], [2, 3], [2, 4]]

[]

</pre>

=={{header|Scala}}==

Function returning the n-ary product of an arbitrary number of lists, each of arbitrary length:

 

 

/**

}

}

and usage:

{{out}}

<pre>{(1, 3), (1, 4), (2, 3), (2, 4)}</pre>

 

{{out}}

<pre>{(3, 1), (3, 2), (4, 1), (4, 2)}</pre>

 

{{out}}

<pre>{}</pre>

 

{{out}}

<pre>{}</pre>

 

{{out}}

<pre>{(1776, 7, 4, 0), (1776, 7, 4, 1), (1776, 7, 14, 0), (1776, 7, 14, 1), (1776, 7, 23, 0), (1776, 7, 23, 1), (1776, 12, 4, 0), (1776, 12, 4, 1), (1776, 12, 14, 0), (1776, 12, 14, 1), (1776, 12, 23, 0), (1776, 12, 23, 1), (1789, 7, 4, 0), (1789, 7, 4, 1), (1789, 7, 14, 0), (1789, 7, 14, 1), (1789, 7, 23, 0), (1789, 7, 23, 1), (1789, 12, 4, 0), (1789, 12, 4, 1), (1789, 12, 14, 0), (1789, 12, 14, 1), (1789, 12, 23, 0), (1789, 12, 23, 1)}</pre>

 

{{out}}

<pre>{(1, 30, 500), (1, 30, 100), (2, 30, 500), (2, 30, 100), (3, 30, 500), (3, 30, 100)}</pre>

 

{{out}}

<pre>{}</pre>

=={{header|Scheme}}==

(define cartesian-product (lambda (xs ys)

(if (or (zero? (length xs)) (zero? (length ys)))

> (nary-cartesian-product '((1 2)(a b)(x y)))

((1 a x) (1 a y) (1 b x) (1 b y) (2 a x) (2 a y) (2 b x) (2 b y))

=={{header|Sidef}}==

In Sidef, the Cartesian product of an arbitrary number of arrays is built-in as ''Array.cartesian()'':

 

Alternatively, a simple recursive implementation:

 

var c = []

 

return r

 

Completing the task:

{{out}}

<pre>

</pre>

The product of an empty list with any other list is empty:

{{out}}

<pre>

</pre>

Extra credit:

{{out}}

<pre>

</pre>

 

{{out}}

<pre>

[]

</pre>

=={{header|SQL}}==

If we create lists as tables with one column, cartesian product is easy.

create table L1 (value integer);

insert into L1 values (1);

insert into L2 values (4);

-- get the product

{{out}}

<pre> VALUE VALUE

1 4

2 3

Product with an empty list works as expected (using the tables created above):

{{out}}

<pre>no rows selected</pre>

insert into L2 values (30);

create table L3 (value integer);

insert into L3 values (100);

-- product works the same for as many "lists" as you'd like

{{out}}

<pre> VALUE VALUE VALUE

2 30 100

3 30 100</pre>

=={{header|Standard ML}}==

| prodList ((x::xs), ys) = map (fn y => (x,y)) ys @ prodList (xs, ys)

 

 

{{out}}

- naryProdList [[1, 2, 3], [], [500, 100]];

val it = [] : int list list</pre>

=={{header|Stata}}==

 

In Stata, the command '''[https://www.stata.com/help.cgi?fillin fillin]''' may be used to expand a dataset with all combinations of a number of variables. Thus it's easy to compute a cartesian product.

 

 

+-------+

3. | 2 3 1 |

4. | 2 4 0 |

 

The other way around:

 

 

+-------+

3. | 4 1 1 |

4. | 4 2 0 |

 

Note, however, that this is not equivalent to a cartesian product when one of the variables is "empty" (that is, only contains missing values).

 

 

+-------+

1. | 1 . 0 |

2. | 2 . 0 |

 

This command works also if the varaibles have different numbers of nonmissing elements. However, this requires additional code to remove the observations with missing values.

 

 

+-----------+

|---------------------|

6. | 3 5 6 1 |

=={{header|Swift}}==

 

{{trans|Scala}}

 

var ret = arr

 

print(cartesianProduct([1776, 1789], [7, 12], [4, 14, 23], [0, 1]))

print(cartesianProduct([1, 2, 3], [30], [500, 100]))

 

{{out}}

[[1, 30, 500], [1, 30, 100], [2, 30, 500], [2, 30, 100], [3, 30, 500], [3, 30, 100]]

[]</pre>

=={{header|Tailspin}}==

'{1,2}x{3,4} = $:[by [1,2]..., by [3,4]...];

' -> !OUT::write

'year {1776, 1789} × month {7, 12} × day {4, 14, 23} = $:{by [1776, 1789]... -> (year:$), by [7, 12]... -> (month:$), by [4, 14, 23]... -> (day:$)};

' -> !OUT::write

{{out}}

<pre>

year {1776, 1789} × month {7, 12} × day {4, 14, 23} = {day=4, month=7, year=1776}{day=4, month=7, year=1789}{day=4, month=12, year=1776}{day=4, month=12, year=1789}{day=14, month=7, year=1776}{day=14, month=7, year=1789}{day=14, month=12, year=1776}{day=14, month=12, year=1789}{day=23, month=7, year=1776}{day=23, month=7, year=1789}{day=23, month=12, year=1776}{day=23, month=12, year=1789}

</pre>

=={{header|Tcl}}==

proc cartesianProduct {l1 l2} {

set result {}

puts "result: [cartesianNaryProduct {{1 2 3} {} {500 100}}]"

 

{{out}}

<pre>

result:

</pre>

 

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Module Module1

End Sub

 

{{out}}

<pre>{(1, 3), (1, 4), (2, 3), (2, 4)}

{(1, 30, 500), (1, 30, 100), (2, 30, 500), (2, 30, 100), (3, 30, 500), (3, 30, 100)}

{}</pre>

=={{header|Wren}}==

{{trans|Kotlin}}

{{libheader|Wren-seq}}

 

var prod2 = Fn.new { |l1, l2|

printProdN.call([ [1, 2, 3], [30], [500, 100] ])

printProdN.call([ [1, 2, 3], [], [500, 100] ])

 

{{out}}

Cartesian product is build into iterators or can be done with nested

loops.

L(L(1,3),L(1,4),L(2,3),L(2,4))

zkl: foreach a,b in (List(1,2),List(3,4)){ print("(%d,%d) ".fmt(a,b)) }

 

zkl: Walker.cproduct(List(3,4),List(1,2)).walk().println();

 

The walk method will throw an error if used on an empty iterator but the pump

method doesn't.

Exception thrown: TheEnd(Ain't no more)

 

L()

zkl: Walker.cproduct(List,List(3,4)).pump(List).println();

L(L(1776,7,4,0),L(1776,7,4,1),L(1776,7,14,0),L(1776,7,14,1),L(1776,7,23,0),L(1776,7,23,1),L(1776,12,4,0),L(1776,12,4,1),L(1776,12,14,0),L(1776,12,14,1),L(1776,12,23,0),L(1776,12,23,1),L(1789,7,4,0),L(1789,7,4,1),L(1789,7,14,0),L(1789,7,14,1),L(1789,7,23,0),L(1789,7,23,1),L(1789,12,4,0),L(1789,12,4,1),...)

 

 

zkl: Walker.cproduct(L(1,2,3),List,L(500,100)).pump(List).println();