Comments on: Logo, Ruby & JavaScript

By: Brian Adkins

Brian Adkins — Sun, 16 Oct 2011 21:28:51 +0000

Here's a better cartesian using nested folds that's about twice as fast as the concat / map version:

fun cartesian [] = []
  | cartesian ([x]) = map (fn e => [e]) x
  | cartesian (x::xs) =
    let val tailCross = cartesian xs
    in foldr (fn (x',result) => 
        foldr (fn (tc,l) => (x'::tc) :: l ) result tailCross) [] x
    end

By: Brian Adkins

Brian Adkins — Thu, 13 Oct 2011 22:14:48 +0000

I recently had a problem pop up where I needed to create a cartesian product of N lists. I'm coding it in Standard ML, so I now have a new entry in that language :) Pretty concise I think:

fun cartesian ([x]) = map (fn e => [e]) x
  | cartesian (x::xs) =
    let val tailCross = cartesian xs
    in concat(map (fn e => map (fn e2 => e::e2) tailCross) x) end
    
fun choices xs = map join (cartesian xs)

The Standard ML REPL abbreviated the list, but it works fine:

- choices [["Small","Medium", "Large"],["vanilla", "ultra chocolate", "lychee", "rum raisin", "ginger"],["cone", "cup"]];
val it =
  ["Small vanilla cone","Small vanilla cup","Small ultra chocolate cone",
   "Small ultra chocolate cup","Small lychee cone","Small lychee cup",
   "Small rum raisin cone","Small rum raisin cup","Small ginger cone",
   "Small ginger cup","Medium vanilla cone","Medium vanilla cup",...]
  : string list

By: Python combinations « I gotta have my orange juice.

Python combinations « I gotta have my orange juice. — Tue, 06 Oct 2009 17:43:24 +0000

[...] a comment » In September 2007, Brian Adkins posted a simple Logo program to print all possible combinations of lists of items, and asked for alternatives in other [...]

By: Scott Moonen

Scott Moonen — Mon, 17 Aug 2009 17:04:45 +0000

Ha, well, turns out that the clojure-contrib library, a standard part of any serious Clojure setup, has some built-in combinatorics support. That brings the Clojure sample down to a simple call to "cartesian-product". I use "apply" below since cartesian-product expects the choices to be supplied as a series of arguments rather than a list of lists.

(use 'clojure.contrib.combinatorics)

(def choices
  '(("small" "medium" "large")
    ("vanilla" "ultra chocolate" "lychee" "rum raisin" "ginger")
    ("cone" "cup")))

(doseq [x (apply cartesian-product choices)] (apply println x))

By: Scott Moonen

Scott Moonen — Fri, 07 Aug 2009 18:49:01 +0000

I've also tried a similar approach in Clojure. I tried to combine Clojure's (for) macro with (gensym), but (for) didn't like anything other than a literal vector, so I couldn't make any progress there. Instead I took a simple recursive approach, as with many of the solutions above:

(def choices
  '(("small" "medium" "large")
    ("vanilla" "ultra chocolate" "lychee" "rum raisin" "ginger")
    ("cone" "cup")))

(defn combo [l]
  (if (empty? (rest l))
    (first l)
    (for [x (first l) y (combo (rest l))] (str x " " y))))

(doseq [x (combo choices)] (println x))

By: Scott Moonen

Scott Moonen — Fri, 07 Aug 2009 18:47:34 +0000

A lot of the replies used Brian’s original technique of passing in a “sofar”. My Python version avoided this and did the concatenation on the return path, which seems a little more like the “functional way”. Brian pointed out to me that my original Python version misunderstood the intentions for “ultra chocolate”. A briefer and more correct version is available here: http://scott.andstuff.org/PythonSpikes

By: Scott Moonen

Scott Moonen — Fri, 07 Aug 2009 16:29:09 +0000

Brian, Enumerable::inject is the Ruby equivalent of Python’s reduce. Looks like Enumerable::reduce was introduced as a synonym in Ruby 1.8.7.

By: XXX

XXX — Tue, 11 Nov 2008 02:04:32 +0000

APL:

?,??.{?,' ',?}/('small' 'medium' 'large')('vanilla' 'ultra chocolate' 'lychee' 'rum raisin' 'ginger')('cone' 'cup')

J (2 solutions):

>,{ ('small';'medium';'large');('vanilla';'ultra chocolate';'lychee';'rum raisin';'ginger'); , { options

By: Ric

Ric — Tue, 11 Nov 2008 01:13:01 +0000

There are some APL, J & K versions of this program in this comp.lang.apl thread. Here is a version in J:

   Options=: ;: each ('small large medium');('ginger lychee rum_raisin ultra_choc vanilla');('cone cup')
   choices=: monad : ';:^:_1 >,{ y'
   choices Options
small vanilla cone
small vanilla cup
small ultra_choc cone
...
large rum_raisin cup
large ginger cone
large ginger cup

By: Neil

Neil — Sat, 02 Feb 2008 18:22:15 +0000

One more:


choices xss = mapM_ (putStrLn . unwords) (sequence xss)

main = choices [["small", "medium", "large"],
 ["vanilla", "ultra chocolate", "lychee", "rum raisin", "ginger"],
 ["cone", "cup"]]