Logo, Ruby & JavaScript

Jordan L. contributed this Java version (I added class wrapper and normalized choice strings).

import java.util.*;

public class Choices {
  public static void choices(List<Object[]> choices, String sofar) {
    if (choices.isEmpty())
      System.out.println(sofar);
    else
      for (Object choice : choices.get(0))
        choices(choices.subList(1, choices.size()),
          sofar + choice.toString() + " ");
  }

  public static void main(String[] args) {
    choices(Arrays.asList(new Object[][] {
      { "small", "medium", "large" },
      { "vanilla", "ultra chocolate", "lychee", "rum raisin", "ginger" },
      { "cup", "cone" } }), "");
  }
}

Here’s a Common Lisp version, but I’m hoping some kind soul on comp.lang.lisp will provide me with pointers to make it cleaner. Especially with the print-choice function.

(defun print-choice (lst)
  (dolist (i lst) (format t "~a " i))
  (format t "~%"))

(defun choices (menu sofar)
  (if menu
    (dolist (i (car menu))
      (choices (cdr menu) (append sofar (list i))))
    (print-choice sofar)))

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

OK, here’s a C# version. No need for a namespace declaration if we’re OK running in the default namespace. No need for a using statement either, if you fully qualify your types.

Chip H.

class Program
{
  static void Main(string[] args) {
    string[] sizes = new string[] { "small ", "medium ", "large " };
    string[] flavors = new string[] { "vanilla ", "ultra chocolate ", "lychee ", "rum raisin ", "ginger " };
    string[] servings = new string[] { "cone", "cup" };

    foreach (string size in sizes)
      foreach (string flavor in flavors)
        foreach (string serving in servings)
          System.Console.WriteLine(size + flavor + serving);
  }
}

Scott, extra points for creativity :) Darn you for causing me to translate that back to other languages now…

My bad. Proc#[] is a synonym for Proc.call, so the following will work:

choices[q]

instead of:

choices.call(q)

I’m not sure it’s much of an improvement though, since it makes the function call look like an array reference! I think Scheme wins out here for consistency:

(expr arg1 arg2 … )

whatever expr evaluates to is executed as a function call:

((if (< 1 2) + -) 3 4) -> 7

My first instinct in python turns the cross product function inside out which may not optimize as well. Shame, because it feels a lot more readable to me.

def cross(aa):
    if len(aa) == 0:
        return [()]
    else:
        return sum([[(x,) + y for x in aa[0]] for y in cross(aa[1:])], [])

def choices(menu):
    return "\\n".join(" ".join(x) for x in cross(menu))

print choices([['small',  'medium',  'large'],
         ["vanilla","ultra chocolate","lychee","rum rasin","ginger"],
         ['cup', 'cone']])

Please forgive my amature Haskell. I don’t know whether there is a cross product function in one of its libraries, but writing one isn’t too hard.

choices (xs:[]) = xs
choices (xs:xss) = foldr ((++) . (\\ys -> map (++ " " ++ ys) xs)) [] (choices xss)

main = putStr (unlines(
       choices [["small",  "medium",  "large"],
                ["vanilla","ultra chocolate","lychee","rum rasin","ginger"],
                ["cup", "cone"]]
                      ))

Note from Brian: this didn’t seem to work with hugs, so I used ghc with no problems. 1) save code to choices.hs, 2) ghc choices.hs, 3) ./a.out

Got a helpful response on comp.lang.lisp that replaced my print-choice function with a simple format. I’m really liking Common Lisp:

(defun choices (menu &optional (sofar '()))
  (if menu
    (dolist (i (car menu))
      (choices (cdr menu) (append sofar (list i))))
    (format t "~{~a~^ ~}~%" sofar)))

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

A Smalltalk version.

“First, a new subclass called Counter was constructed from the Array class. Two variables were added to the class: slave and value. The following methods were added.”

initialize
	slave := nil. value := 1. ^self

increment
	value := value + 1.
	value > self size
		ifTrue:
			[value := 1.
			slave notNil ifTrue: [slave increment]]

last
	^value = self size and: [slave isNil ifFalse: [slave last] ifTrue: [true]]

slave
	^slave

slave: anObject
	slave := anObject

value
	Transcript show: (self at: value); show: ' '.
	slave notNil ifTrue: [slave value].
	^value.

"The choices program."

counter := Counter withAll: #('small' 'medium' 'large').
counter slave: (Counter withAll: #('vanilla' ultra 'chocolate' 'lychee' 'rum raisin' 'ginger')).
counter slave slave: (last := (Counter withAll: #('cone' 'cup'))).
[counter last] whileFalse:
	[x value.
	x increment.
	Transcript cr].
x value

Clean:

items =: [["small","medium","large"],["vanilla","chocolate"],["cup","cone"]]
menu i
| i == [] = “”
= hd i +++ “\n” +++ menu (tl i)
Start = menu [x+++” “+++y+++” “+++z \\ x

I thought I’d put a first draft up of a version in Arc :)

(def joinstr (lst (o sep " "))
  (if lst
    (string (car lst) (apply string (map [string sep _] (cdr lst))))
    ""))

(def choices (menu (o result '()))
  (if menu
    (each x (car menu)
      (choices (cdr menu) (cons x result)))
    (prn (joinstr:rev result))))

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

Sorry – couldn’t help writing another Haskell version:


choices :: [[String]] -> IO ()
choices xss = mapM_ (putStrLn . unwords) (f xss)
where f [] = return []
f (zs:zss) = do x

Having just usefully taught myself how to use ampersands etc. in order to prevent “<-” being parsed as a comment, I can finally unveil my Haskell version.

Thanks for your patience. (And fingers crossed for third attempt…)

Ben’s Haskell version is shorter, of course, but I think mine might be more ‘idiomatic’ in that it abides by old Haskell maxim: ‘use monads whenever you see the slightest opportunity to show off the fact that you know how they work’.

choices :: [[String]] -> IO ()
choices xss = mapM_ (putStrLn . unwords) (f xss)
    where f [] = return []
          f (zs:zss) = do x <- zs
                          xs <- f zss
                          return $ x:xs

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

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

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.

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))