A better way to "comma and and-ize" an IEnumerable in C#

Question

Possible Duplicate:
LINQ list to sentence format (insert commas & “and”)

Imagine these inputs and results:

[] -> ""

["Hello World!"] -> "Hello World!"

["Apples", "bananas"] -> "Apples, and bananas" (put your grammar books away)

["Lions", "Tigers", "Bears"] -> "Lions, Tigers, and Bears" (oh my!)

Now, imagine that the inputs are all of IEnumerable<string>. What is a good (where good may encompass "small and tidy", "easy to understand", "uses the full ability of LINQ", or other as long as it's justified) to write a function in C# to do this? I would really like to avoid "imperative loop" approaches.

My current approach looks like:

string Commaize (IEnumerable<string> list) {
    if (list.Count() > 1) {
        list = list.Take(list.Count() - 2).Concat(
            new[] { list.Reverse().Take(2).Reverse()
                        .Aggregate((a, b) => a + " and " + b) });
    }
    return String.Join(", ", list.ToArray());
}

But it just doesn't feel very "good". It's for .NET3.5 so the ToArray() bit is required here. If list is null the result is UB.

Not an *exact* duplicate... this one uses the Oxford comma, the other question doesn't. It can actually change the implementation (I know it changes mine a bit). Also, see [Jeff Atwood's recent blog post](http://blog.stackoverflow.com/2010/11/dr-strangedupe-or-how-i-learned-to-stop-worrying-and-love-duplication/) about how duplication is actually a good thing. — Thomas Levesque, Nov 21 '10 at 21:02

score 7 · Answer 1 · answered Nov 21 '10 at 20:32

7

Unlike other answers (except the one posted by CodeInChaos), this implementation only enumerates the input sequence once. This can be important if the cost of enumerating it is high (e.g. DB query, web service call...)

string Commaize (IEnumerable<string> list)
{
    string previous = null;
    StringBuilder sb = new StringBuilder();
    foreach(string s in list)
    {
        if (previous != null)
            sb.AppendFormat("{0}, ", previous);
        previous = s;
    }
    if (previous != null)
    {
        if (sb.Length > 0)
            sb.AppendFormat("and {0}", previous);
        else
            sb.Append(previous);
    }
    return sb.ToString();
}

answered Nov 21 '10 at 20:32

Thomas Levesque

286,951
70
623
758

Yours takes less memory because you don't have the `ToList`/`ToArray` calls. So it's probably be a bit faster. – CodesInChaos Nov 21 '10 at 20:38
You traverse list two time not one time : sb.ToString(); traverse it – Saeed Amiri Nov 22 '10 at 09:40
@Saeed: sb is a StringBuilder, it doesn't traverse any list... – Thomas Levesque Nov 22 '10 at 10:29
So how going to convert the char stream to string? – Saeed Amiri Nov 22 '10 at 12:01
@Saeed, it just returns the string currently in the StringBuilder buffer. – Thomas Levesque Nov 22 '10 at 12:41
+1 I haven't tested your method BUT yours are the only sane method currently :) thumbs up. Yours does NOT use insanely many LINQ methods nor does it aggregate strings in a O(n^2) fashion. And it only iterates the list once. – Lasse Espeholt Nov 22 '10 at 16:05
Tomas, not related to this question but how you can write `n²`? in other application you do it or in SO? thanks :D – Saeed Amiri Nov 22 '10 at 18:51
@Saeed: this character has its own key on my keyboard (French AZERTY layout). Not sure why, since it's not used very often... – Thomas Levesque Nov 22 '10 at 19:56

diceguyd30 · Answer 2 · 2010-11-29T21:22:25.600

string Commaize (IEnumerable<string> list) {
    var last = list.LastOrDefault();
    return (last != null) ?
        list.Aggregate((acc,x) => acc + ", " + (x == last ? "and " : "") + x) :
        string.Empty;
}

For a list of 10,000 strings this ran in .5 seconds (compare to Thomas' that runs in about .005 seconds). Not the fastest, but I do like the readability.

EDIT:

string Commaize (IEnumerable<string> list) {
    var enumer = list.GetEnumerator();
    if (enumer.MoveNext()) {
        var c = enumer.Current;
        return (enumer.MoveNext()) ?
        list.Aggregate((acc,x) => acc + ", " + (!enumer.MoveNext() ? "and " : "") + x) :
            c;
    }
    return string.Empty;
}

This version doesn't have the equality problem of the first,.....but at the cost of readability, which was really the only thing the first function had going for it.

I voted for this, although this will not work if `x == last`, when "x is not last". I can be made slightly more resilient using object-identity `(object)x == (object)last`, but that still has the restriction that a particular object can't be duplicated in the input. — , Nov 28 '10 at 23:02

CodesInChaos · Accepted Answer · 2010-11-21T20:04:50.107

1

string Commaize (IEnumerable<string> sequence)
{
    IList<string> list=sequence as IList<string>;
    if(list==null)
      list=sequence.ToList();
    if(list.Count==0)
      return "";
    else if(list.Count==1)
      return list.First();
    else
      return String.Join(", ", list.Take(list.Count-1).ToArray()) + " and " + list.Last();
}

The overhead of this is the allocation of a few additional arrays(one ToList() and one ToArray() call, which probably both use allocation of exponentially growing arrays, so the number of allocated arrays is larger than two).

edited Nov 21 '10 at 20:04

answered Nov 21 '10 at 19:39

CodesInChaos

106,488
23
218
262

+1. I really like this use of Take and Last (I had forgotten about Last) and the separation of what is "join'ed". However, I dislike the "conversion checks" at top. – Nov 28 '10 at 23:04

score 0 · Answer 4 · edited May 23 '17 at 10:26

Here's my implementation (using .NET 4.0) of it found in Eric Lippert's challenge:

static string CommaQuibbling<T>(IEnumerable<T> items)
{
    int count = items.Count();
    var quibbled = items.Select((Item, index) => new { Item, Group = (count - index - 2) > 0})
                        .GroupBy(item => item.Group, item => item.Item)
                        .Select(g => g.Key
                            ? String.Join(", ", g)
                            : String.Join(" and ", g));
    return "{" + String.Join(", ", quibbled) + "}";
}

Add the Oxford comma if you want it and remove the extra braces if you don't.

Ian Mercer · Answer 5 · 2010-11-22T15:55:36.807

0

From the linked question, an extension method:

public static string ToAndList<T>(this IEnumerable<T> list)
{
   return string.Join(" ", list.Select((x, i) => x.ToString() + (i < list.Count() - 2 ? ", " : (i < list.Count() - 1 ? " and" : ""))));
}

Edit: Note: I think we can safely assume that English sentences aren't going to cause any performance issues here with the repeated use of Count() and/or that future compilers might be able to optimize this for us. But yes, if you want to optimize it for enumerable collections that don't implement Count efficiently, you can move Count() out of the statement.

edited Nov 22 '10 at 15:55

answered Nov 21 '10 at 20:11

Ian Mercer

38,490
8
97
133

1

This is O(n^2), but might still be acceptable for small lists. – CodesInChaos Nov 21 '10 at 20:36
1

You might want to move `list.Count()` out of the loop. – CodesInChaos Nov 21 '10 at 20:42
1

Actually it's O(n²) only if the input sequence doesn't implement ICollection... But anyway, when you don't know what the input actually is, you shouldn't call `Count()` repeatedly on it – Thomas Levesque Nov 21 '10 at 20:56

A better way to "comma and and-ize" an IEnumerable in C#

5 Answers5