Reversing a string in C# - is it really that difficult!

I've been interviewing people for a C# developers position recently which has taken the usual "technical questions, chat, random questions, any questions for us" kind of format which I'm sure most people who've been looking for a job recently will be familiar with.

One of the technical questions we've been asking recently is "Can you describe how you would reverse a string in C#". Note, we're not asking anyone to code a full answer, just describe how they would do it.

This is one of those pretty standard interview questions, much like the FizzBuzz question, which is presented to see if candidates can demonstrate a basic understanding of a programming language and show that they can understand simple requirements. And yet, it seems to throw so many candidates!

The requirements are simple.

Take a string such as "ignoring the voices"
Reverse the characters of the string
Output the result (i.e. "seciov eht gnirongi")

As with most things there are a number of ways to achieve this goal, some more efficient than others, some more geeky than others, but still there are varied number of ways to do it, so I wanted to demonstrate a couple of methods here to show it is possible. To date I've only received a single correct answer, the other answers have been either non-existent (I don't know how) or far from the mark.

Method 1 - The agnostic approach

This method is the agnostic approach as it shows an algorithm rather than a platform specific solution. This is a good solution in an interview as it shows that you understand the problem and can devise algorithms to solve it, although it's worth saying that there may be a solution more relevant to the platform. The solution is simple, work your way in to the middle of the string (character array) from the start and end of the string, swapping the characters as you go. The important thing is to stop when you get half way through the string, otherwise you'll reverse the same characters again and arrive back at the original string. The example is presented as an extension method.

	public static class StringExtensions
	{
	public static string ReverseString(this string input)
	{
	var chr = input.ToCharArray();
	var tmp = '0';
	var i = 0;
	var j = chr.Length - 1;
	var end = chr.Length / 2;
	while (i < end)
	{
	tmp = chr[i];
	chr[i] = chr[j];
	chr[j] = tmp;
	i++;
	j--;
	}
	return new string(chr);
	}
	}
	void Main()
	{
	Console.WriteLine("Hello World!".ReverseString());
	}

view raw Reverse1.cs hosted with ❤ by GitHub

Method 2 - The C# (.NET 4) approach

The .NET framework provides a large number of methods available on all of the standard types, these can help solve this problem in a way which is specific to C# and the .NET platform. The important thing to remember is that strings are just arrays of characters, and so any methods which can be applied to arrays can be applied to strings as character arrays. More recently some methods which were only for arrays have been moved to strings as well, conveniently one of them is the Reverse method. That's not to say that you can just reverse a string directly as the Reverse method returns an IEnumerable object, but the IEnumerable object can return an array and the string constructor can take a character array to initialize a string object with, so we get the following method.

	public static class StringExtensions
	{
	public static string ReverseString(this string input)
	{
	return new string(input.Reverse().ToArray());
	}
	}
	void Main()
	{
	Console.WriteLine("Hello World!".ReverseString());
	}

view raw Reverse2.cs hosted with ❤ by GitHub

This is a vastly simpler implementation than the first, but is it any better? Well it shows an understanding of the language which is a positive, but not of algorithm implementation, so it's neither better or worse than the first method. The best answer to give would be the first answer followed by the second to show an understanding of algorithms and of the required platform.

Of course from these you can devise variations on the problem, such as reversing the words in a string whilst keeping the characters of each word in the correct direction.

	public static class StringExtensions
	{
	public static string ReverseSentance(this string input)
	{
	return String.Join(" ", input.Split(' ').Reverse());
	}
	}
	void Main()
	{
	Console.WriteLine("Ignoring The Voices".ReverseSentance()); // Voices The Ignoring
	}

view raw ReverseSentance.cs hosted with ❤ by GitHub

Or even reversing the characters of each word, but keeping the words themselves in the correct order.

	public static class StringExtensions
	{
	public static string ReverseWord(this string input)
	{
	return new string(input.Reverse().ToArray());
	}
	public static string ReverseWordsInSentance(this string input)
	{
	return String.Join(" ", input.Split(' ').Select(n => n.ReverseWord()));
	}
	}
	void Main()
	{
	Console.WriteLine("Ignoring The Voices".ReverseWordsInSentance()); // gnirongI ehT secioV
	}

view raw ReverseWordsInSentance.cs hosted with ❤ by GitHub

So why do some programmers struggle with these kind of questions? Is this indicative of programmers as a whole or is this just a lull? I can only guess at the reason, but non-the-less it feels concerning at the moment.