Comma Quibbling

re: Comma Quibbling

Hasan Khan — Sat, 08 Oct 2011 15:32:52 GMT

Without too many or nested if statements. Flat code.

public static string CommaQuibbling(IEnumerable<string> items)

{

var result = new StringBuilder("{");

string separator, last;

last = separator = "";

bool second = false;

var iter = items.GetEnumerator();

if (iter.MoveNext())

result.Append(iter.Current);

while (iter.MoveNext())

{

second = true;

result.Append(separator).Append(last);

last = iter.Current;

separator = ",";

}

result.Append(second ? " and ": separator).Append(last);

return result.Append("}").ToString();

}

re: Comma Quibbling

Ashok — Wed, 01 Jun 2011 23:17:32 GMT

Just realized this was an old post, but a puzzle is a puzzle.

This is what I came up with in C#.

public string CommaQuibble(IEnumerable<string> data)

{

StringBuilder result = new StringBuilder();

int stringCount = data.Count();

int currentStringIndex = 1;

foreach(string str in data)

{

if(currentStringIndex == 1)

result.Append(str);

else

if(currentStringIndex < stringCount )

result.Append("," + str);

else

if(currentStringIndex == stringCount)

result.Append(" and " + str);

currentStringIndex++;

}

return string.Format("{{{0}}}", result.ToString());

}

re: Comma Quibbling

Alexander Morou — Tue, 12 Apr 2011 10:31:51 GMT

Some of these solutions are so... odd that it makes me scratch my head wondering why.

Here's my take, straight forward:

public static string EnglishWordConcatination(this IEnumerable<string> source)

{

/* *

* If the elements passed in are already an array,

* use it.

* */

string[] sourceArray = source as string[];

int itemCount = 0;

if (sourceArray == null)

{

/* *

* If the elements passed in are already a type-strict

* collection of strings, use it.

* */

var sourceCollection = source as ICollection<string>;

if (sourceCollection != null)

{

sourceArray = new string[itemCount = sourceCollection.Count];

sourceCollection.CopyTo(sourceArray, 0);

}

else

{

/* *

* Otherwise, build a new array assuming

* a small working base set of elements.

* */

sourceArray = new string[2];

foreach (var element in source)

{

if (itemCount == sourceArray.Length)

{

string[] tempArray = new string[itemCount * 2];

sourceArray.CopyTo(tempArray, 0);

sourceArray = tempArray;

}

sourceArray[itemCount++] = element;

}

else

itemCount = sourceArray.Length;

StringBuilder sb = new StringBuilder();

sb.Append('{');

bool first = true;

for (int i = 0; i < itemCount; i++)

{

/* *

* The condition is exclusive, the last is Length - 1.

* */

bool last = (i == (itemCount - 1));

/* *

* Special conditions are the first and last since

* the separator is appended prior to the current

* element.

* */

if (first)

first = false;

else if (last)

sb.Append(" and ");

else

sb.Append(", ");

sb.Append(sourceArray[i]);

}

sb.Append('}');

return sb.ToString();

}

re: Comma Quibbling

Morten Boysen — Wed, 10 Nov 2010 14:56:03 GMT

public class StringSequenceFormatter

{

public string Format(IEnumerable<string> sequence)

{

string commaList = RecursiveFormatter(sequence);

return '{' + commaList + '}';

}

private string RecursiveFormatter(IEnumerable<string> sequence)

{

if (sequence.Count() == 0)

{

return string.Empty;

}

else if (sequence.Count() == 1)

{

return sequence.First();

}

else if (sequence.Count() == 2)

{

return sequence.First() + " and " + sequence.Last();

}

else

{

return sequence.First() + ", " + RecursiveFormatter(sequence.Skip(1));

}

re: Comma Quibbling

abatishchev — Fri, 10 Sep 2010 06:54:41 GMT

@David V. Corbin: Whut?? Understand NOTHING from your message.

re: Comma Quibbling

abatishchev — Fri, 10 Sep 2010 06:30:40 GMT

My $0.02 (one-liner)

static string Do(params string[] input)

{

return String.Concat(

"{",

input.Length > 2 ?

String.Concat(

String.Join(", ", input.Take(input.Length - 1)),

" and ",

input.Last()) :

String.Join(" and ", input),

"}");

}

static void Main(string[] args)

{

Console.WriteLine(Do("")); // {}

Console.WriteLine(Do("ABC")); // {ABC}

Console.WriteLine(Do("ABC", "DEF")); // {ABC and DEF}

Console.WriteLine(Do("ABC", "DEF", "G", "H")); // {ABC, DEF, G and H}

}

re: Comma Quibbling

David V. Corbin — Fri, 12 Mar 2010 02:05:31 GMT

@M. McCulloch -They would never work for me either. Your sample contains identfiers that are longe than necessary, redundant white space (and line breaks). All of these items take longer to type, and longer to Parse. There is absolutely NO POINT in wasting these resources!!!!!

FWIW: There was a time when those arguments actually held some weight....glad they are ancient history!

re: Comma Quibbling

M. McCulloch — Fri, 12 Mar 2010 01:42:14 GMT

I don't know what's got into me, but I just wrote an even more terrible version of the recursive one above. This is bordering on diabolical.

static string Quibble666(IEnumerable<string> inList)

{

IEnumerator<string> e = inList.GetEnumerator();

bool more;

return "{" + (e.MoveNext() ? e.Current : "") + Walk666(e, (more = e.MoveNext()), more ? e.Current : "");

}

static string Walk666(IEnumerator<string> e, bool more, string current)

{

return more ? ((more = e.MoveNext()) ? ", " : " and ") + current + Walk666(e, more, more ? e.Current : "") : current + "}";

}

(Anyone who actually codes like this will never work for me!)

re: Comma Quibbling

M. McCulloch — Fri, 12 Mar 2010 00:13:36 GMT

Couldn't resist this despite being a year late.

I don't agree that "readability is terseness". I've seen too much terse but unreadable code which needed to be expanded to be understandable. To wit, here's my terse and unreadable version, comprised of a single line:

static string Quibble1(IEnumerable<string> inList)

{

return "{" + (inList.Count() == 0 ? "" : inList.Count() == 1 ? inList.First() : string.Join(", ", inList.ToArray(), 0, inList.Count() - 1) + " and " + inList.Last()) + "}";

}

But of all the versions I came up with, this one seems to have the best balance of terseness and readability:

static string Quibble2(IEnumerable<string> inList)

{

string[] aList = inList.ToArray();

if (aList.Length <= 1)

return "{" + (aList.Length == 0 ? "" : aList[0]) + "}";

string mainList = string.Join(", ", aList, 0, aList.Length - 1);

return "{" + mainList + " and " + aList[aList.Length - 1] + "}";

}

Except Eric's rules stipulated that only the methods of IEnumerable<> were allowed, so the above two solutions are invalid. Here's my first valid solution:

static string Quibble3(IEnumerable<string> inList)

{

IEnumerator<string> e = inList.GetEnumerator();

string result = "{";

if (e.MoveNext())

result = result + e.Current;

bool more = e.MoveNext();

while (more)

{

string current = e.Current;

more = e.MoveNext();

result = result + (more ? ", " : " and ") + current;

}

return result + "}";

}

Using StringBuilder would be more efficient for large lists, of course, but the structure's the same.

And for fun, here's a valid version using recursion. But I wouldn't usually write code like this (I don't like inline assignment, or repurposing of variables):

static string Quibble4(IEnumerable<string> inList)

{

IEnumerator<string> e = inList.GetEnumerator();

string s = "{";

if (e.MoveNext())

s = s + e.Current;

return s + walk(e, e.MoveNext());

}

static string walk(IEnumerator<string> E, bool more)

{

if (!more)

return "}";

string current = E.Current;

return ((more = E.MoveNext()) ? ", " : " and ") + current + walk(E, more);

}

re: Comma Quibbling

GRico — Fri, 04 Dec 2009 20:03:42 GMT

Sorry about that last post....I had a brain f..., it obviously does not work. Following one should do the trick. Simple and easy IMHO.

public static string CommaQuibble(IEnumerable<string> quibbleMe)

{

StringBuilder commaQuibbled = new StringBuilder();

IEnumerator<string> quibblies = quibbleMe.GetEnumerator();

commaQuibbled.Append('{');

quibblies.MoveNext();

if (quibblies.Current != null)

{

commaQuibbled.Append(quibblies.Current);

quibblies.MoveNext();

while (quibblies.Current != null)

{

string nextQuibbly = quibblies.Current;

if (quibblies.MoveNext())

commaQuibbled.Append(", ");

else

commaQuibbled.Append(" AND ");

commaQuibbled.Append(nextQuibbly);

}

commaQuibbled.Append('}');

return commaQuibbled.ToString();

}