You’re right again about my C# solution; the boolean variable is indeed ugly, but on the other hand it makes it possible to represent the same idea in the same way in all the examples.

There are situations where there isn’t any superior alternative: for instance C++ iterators do not have a notion of first element so in order to check for it an additional loop control variable would be required, so as not to move the starting iterator.

[1,2,3].inject {|sum, element| sum + element } gives 6.

When the array is empty, inject returns nil. So I add the

… || ”

to cover that case. If inject returns nil, we return empty string.

So there are two “ifs” in the second solution, the first is in the “||” which treats the special case of empty array, and the second is hidden in “inject” which will just return the first element if the array is a singleton.

I think your C# solution would be prettier if you used

if (e == elements.first)

in place of the ugly boolean flag. You need a test for the first case, anyways. One way is to test if the accumulator is empty, the other is to test if the current array element is the first.

Here’s another solution that is more similar to yours. The intertwine function captures the behaviour of joining and might be useful in other places.

require “test/unit”

def intertwine(array, separator)
for element in array
yield separator unless element == array.first
yield element
end
end

def join(array, separator)
result = “”
intertwine(array, separator) do |element|
result += element
end
result
end

class TestLibraryFileName < Test::Unit::TestCase
def test_case_name
assert_equal "", join([], ", ")
assert_equal "x", join(["x"], ", ")
assert_equal "x, y", join(["x", "y"], ", ")
end
end

your first solution fails when the input array is empty!

My next-to-favourite solution (in Ruby) would be

def join(array, separator)
result = “”
for element in array
result += separator unless result.empty?
result += element
end
result
end

And this would be the algorithm I would use in old school languages like Java or C++. But if you have nice “higher order” methods in your language, you can shorten it to something as cool as:

def join(array, separator)
array.inject {|a,b| a + separator + b} || “”
end