import Control.Monad (replicateM)
things :: [String]
things = ["A","B","C","D"]
delimiters :: [String]
delimiters = ["and", ","]
result = map (++ " D") combinations''' where
combinations''' = map unwords combinations''
combinations'' = map concat combinations'
combinations' = map (map (\(x,y) -> [x,y])) combinations
combinations = map (zip $ init things) $ replicateM (length things - 1) delimiters
main = putStr $ unlines resultrunhaskell program ~>
A and B and C and D
A and B and C , D
A and B , C and D
A and B , C , D
A , B and C and D
A , B and C , D
A , B , C and D
A , B , C , D
[["and","and","and"],
["and","and",","],
["and",",","and"],
["and",",",","],
[",","and","and"],
[",","and",","],
[",",",","and"],
[",",",",","]][[("A","and"),("B","and"),("C","and")],
[("A","and"),("B","and"),("C",",")],
[("A","and"),("B",","),("C","and")],
[("A","and"),("B",","),("C",",")],
[("A",","),("B","and"),("C","and")],
[("A",","),("B","and"),("C",",")],
[("A",","),("B",","),("C","and")],
[("A",","),("B",","),("C",",")]]let things be the list of length n of things
let delims be the list of length m of delimiters
let result be the list of resulting strings
let counter be a base-m number with n-1 digits (initialised to 0)
repeat m^(n-1) times
let temp be the mapping of counter to delims # e.g. 0 -> ","; 1 -> "and"; 101 becomes "and", ",", "and"
intersperse elements of temp between things and add that to result # e.g. "A " + "and " + "B " + ", " + "C " + "and " + "D"
increment counter # e.g. 101 -> 110
program Variant_List_Creator; {$mode objfpc} {$H+}
procedure p(const tmp : String; const i : Integer);
begin
if (i > ParamCount) then begin
WriteLn(tmp);
exit;
end;
p(tmp + ', ' + ParamStr(i), i + 1);
p(tmp + ' and ' + ParamStr(i), i + 1);
end;
begin
if (ParamCount < 2) then begin
WriteLn('Error: need at least 2 parameters');
Halt(1);
end;
p(ParamStr(1), 2);
end.Hooray for recursion.Lazarus (i.e. FreePascal) project with binary: linkprogram Variant_List_Creator; {$mode objfpc} {$H+} procedure p(const tmp : String; const i : Integer); begin if (i > ParamCount) then begin WriteLn(tmp); exit; end; p(tmp + ', ' + ParamStr(i), i + 1); p(tmp + ' and ' + ParamStr(i), i + 1); end; begin if (ParamCount < 2) then begin WriteLn('Error: need at least 2 parameters'); Halt(1); end; p(ParamStr(1), 2); end.
Recursive implementations of these types of things are often sweet and short. Another possibility is to notice that you essentially have all possible combinations of (n-1) bits (where n is the number of elements). This means that if you increment an integer from 0 to 2n-1, then you can output each element and between them either a comma or "and" depending on the correspondent bit in the integer. OTOH the recursive implementation is probably more beautiful.
