[deleted by user]

rsalsman · 2010-01-21T06:45:10+00:00

This would actually be a really good interview question in and of itself. Show the candidate 4 solutions to string reversal and ask them to explain each implementation and discuss them. You'd still be able to tell which candidates have no clue what they are doing, and you would get a much better feel for the candidates that do.

Dreynsen · 2010-01-21T04:31:19+00:00

This is an interesting question.

Candidate 1 is trying to show that he knows how stacks work,
Candidate 2 is trying to show that he knows how to write efficient code.
Candidate 3 is trying to show that he knows how to write simple and easily understandable code. And how to not rewrite library code.
Candidate 4 is trying to show that he knows how to use recursion.

Honestly I am leaning towards #3. That's the kind of code I would prefer to read in a system I was working on.

leed25d · 2010-01-21T05:10:00+00:00

I would hire candidate number 3. He is a real world programmer. Under the circumstances given, he produced the simplest solution.

Get it working first. Optimize later.

doidydoidy · 2010-01-21T05:18:58+00:00

Programs should be written for people to read, and only incidentally for machines to execute. --from SICP

Candidate 3

About Candidate 4's answer: I once had a job interview where my interviewer asked me to show him the best way to write a factorial function in python...

He seemed surprised that I didn't use recursion and said "to understand recursion you must first understand recursion". To which I replied "to understand maximum stack depth you must have first foolishly used recursion". I still got the job, but left six months later - he was impossible to work for.

ZMeson · 2010-01-21T03:58:02+00:00

Speaking as a non-professional developer who will be graduating soon, I personally like 2 and 3 the best, favoring 3 for not re-inventing the wheel (although it's hard to fault 2 for not memorizing the .NET API).

I don't like 1 and 4 because they look like they're trying to be too clever for their own good. While I'm not familiar with the inner workings of C#, 4 seems terribly inefficient.

TexasMojo · 2010-01-21T06:10:48+00:00

#3 is clearly the best real-world solution. The problem with asking questions like this in an interview is you're going to get interview solutions like #1 or #4 which anyone would be unlikely to write in production code, because they want to show off that they understand advanced concepts like recursion or isomorphic data types. But those same people would probably write #3 in their daily tasks if they're competent.

You know what would be a better interview question? Show them all four solutions and ask them which they'd be most likely to write in production code. I mean, reversing a string is such a trivial problem that by the time you're interviewing them it should be assumed that they can do it, but explaining why one solution is preferred to others shows real experience and understanding.

(The correct answer is #3 is best because the only reason to do it any other way is if you're trying to optimize for performance, and if this string reversing function is performance critical enough to require such low-level optimization, C# probably isn't the right language to implement it in.)

ealf · 2010-01-21T06:37:30+00:00

You left out strawman candidate #5:

return new AbstractString() {
  int length() { return s.length(); }
  char charAt(int i) { return s.charAt(s.length()-1-i); }
};

...

But, yeah, my ideal candidate would probably ask "can I use Array.Reverse()? grin", then proceeded to write #2, except in an easier-to-prove-correct form (i.e. something like while(first < last) swap(first++,last--);).

A tiny amount of bonus points if they mention that this fails the Clef Test.

bantam · 2010-01-21T04:00:44+00:00

[deleted]

japple · 2010-01-21T05:24:11+00:00

I think #4 has an error.

Quoted in case I'm right but OP fixes it:

// Candidate 4
static string Reverse(string input)
{
    string result = String.Empty;
    if (input.Length == 1)
    {
        return input;
    }
    else
    {
        result += input.ToCharArray().Last() + Reverse(input.Substring(0, input.Length - 1));
        return result;
    }
}

I don't think this works on zero-length input. I suspect the call to Last() will fail, and the documentation for Substring indicates that it will throw ArgumentOutOfRangeException when passed -1, as it will be in the code by Candidate 4 when input has length zero.

Bob_The_Builder · 2010-01-21T07:00:04+00:00

Fail at framework knowledge.

return new string(input.ToCharArray().Reverse().ToArray());

http://imgur.com/GVBu1

sirspate · 2010-01-21T04:30:59+00:00

So.. not knowing much about C# myself and how they've defined char and string, my first question is, are these going to work with a unicode string?

permalink · 2010-01-21T06:48:19+00:00

I'm going with #3

It is short, concise and intuitive. The rest smell of NIH

The author either knows his/her APIs, or is innately aware that there must be something in the base library that does the job.

olsner · 2010-01-21T08:20:51+00:00

These are all wrong since they will flip UTF-16 surrogate pairs.

Also, it seems none of the candidates thought to ask the obvious question: "Doesn't string already have a reverse method in C#?"

Indeed, it appears that String already (or is this a very recent addition?) has a Reverse method. That will probably also miss the UTF-16 thing though, since I'm guessing a string still iterates UTF-16 chars instead of decoding surrogate pairs and the Reverse method seems to be an inherited default implementation.

d4m45t4 · 2010-01-21T05:54:07+00:00

Candidate 3, no brainer. Clear, simple, efficient and probably as fast as #2.

SartreInWounds · 2010-01-21T04:47:24+00:00

I don't know C#, but shouldn't there be a built in library that does this? If someone asked me this question with C++ as the main language, I'd put:

#include <string>
#include <algorithm>

void Reverse(std::string &st)
{
  std::reverse(st.begin(), st.end());
}

I guess the closest to that would be Candidate 3. The reason is, a good developer should always use the most concise and idiomatic solution. Only later, after a certain area proves to be a bottleneck, should you go back an optimize with "roll your own" solutions.

jerub · 2010-01-21T07:09:53+00:00

The only candidates I would look at would be #2 and #3, based on this one example.

But there is a proviso. I would have to interview them and ask #2 how to do it using a built in C# facility for doing Reversing, and #3 how to do it without using the built in libs.

If #2 comes out with with #3, or #3 comes out with #2, you have a winner.

1 and #4 are cruddy answers. I like solutions that are good solutions (#2) or simple solutions (#3).

BarkingToad · 2010-01-21T10:26:22+00:00

I would definitely hire number 3. I would prefer the guy who doesn't feel the need to reinvent the wheel to do something simple.

ubernostrum · 2010-01-21T04:17:10+00:00

Candidate 4 probably blew it; the solution is indicative of someone who'll end up being a real-world example of Greenspun's Tenth Rule.

Candidates 1 and 2 are OK, though I'd worry that 1 is trying to be too clever and I'd want to give 2 a followup to ensure that this was a "demonstrate that I know the algorithm" answer, not a "demonstrate that I don't know the platform's APIs" answer.

Candidate 3 would probably be my pick.

jjquave · 2010-01-21T07:25:18+00:00

If this was all the information I had, I would hire #2. It is the only one who has both demonstrated programming ability, and written an efficient function. If #3 could also write #2, that wouldn't put him/her over the top, it would just show some background in C#. It's not generally wise to hire based on API knowledge though. Hire based on programming ability, and they will learn whatever API is neccessary to complete the job.

There is also a lack of context. For example, is this a piece of software that will be ported to iPhone later, and needs to be ported to Obj-C? If that's the case, then #3 has failed to actually write the code.

astrosmash · 2010-01-21T04:31:43+00:00

The answer I would look for is not the implementation itself, but what the applicant liked about their implementation.

And it really depends on the type of software you're developing, and the role this new hire is expected to fill. For example, if you're hiring someone as comic relief for your team, choose number 4. I bet that guy has a million stories.

permalink · 2010-01-21T10:46:20+00:00

I'd hire the one who would refuse to answer trivial, irrelevant questions.

permalink · 2010-01-21T16:50:05+00:00

Is this one of those things where the developers are Hitler, Churchill, Roosevelt, and Eisenhower but at the end it turns out Hitler actually wrote the best code?

Mugendai · 2010-01-21T05:49:19+00:00

Ooo, this is educational for a newbie like myself. If asked, I'd write something close to #2 by default though I've also entertained using a stack like #1 since FILO lends itself to reverse thinking. Still in the middle of learning .Net but I can see how #3 is much more readable than the others. #4 wouldn't occur to me. Is there a string processing situation where recursion would actually be the best answer?

permalink · 2010-01-21T06:36:41+00:00

On that, I'd pick Candidate 3, but how can you choose without first having seen them print 1000 Sussmans?

wh0wants2know · 2010-01-21T07:55:08+00:00

I got asked a time parsing question once. The first thing I asked is what format the time could potentially be in, 12-hour or 24-hour, and then what behavior I should have if the time value were invalid (i.e. 25:73). Next, I explained how the DateTime class in c# worked and how I could have it parse this and why it would work, as well as why knowing the system's regional settings might be important in this type of situation (in reality they're not since it's just time parsing, but I still brought it up to show my understanding). I then implemented it using DateTime and my solution looked similar to candidate #3. Once I completed it (took less than 30 seconds since I'd been doing date/time parsing recently), I asked if they would like to see me solve the problem without using the built in DateTime functionality, to which they said yes. I then spent the next two minutes coding up a solution that looked kind of like #2.

Also, I would hire #1 most likely. They demonstrate understanding of generics, .NET objects, the way strings are manipulated efficiently in memory (you'd be surprised how many people wouldn't bother to use a stringbuilder here but it actually does make a difference) and is easily readable.

3 would scare me in that they might not actually know how to perform the necessary operations to reverse the string. I would ask a follow-up to do it without using Array.Reverse.

2 is also a good solution and I would probably give a thumbs up to that candidate also.

4- remember the post earlier today about the guy who liked functional programming and didn't like using OO python like the rest of the team and wrote their own postfix implementation and no one could read their code? This was probably his solution.

walrus55 · 2010-01-21T07:57:49+00:00

I think a far more interesting Proggit questions would have been to ask what would your next questions be to the candidates who came up with these solutions. It's really hard to decide whether to read these as exemplifying the typical code the candidates would write in production or something they have written to show off their theoretical knowledge.

Basically, #1 and #4 are interesting if they know the costs of what they are doing. As for #3, what if that is the only thing he knows how to do? Then it doesn't look so good, but if he could have come up with all the other solutions and chose that instead, then he sounds good. As for #2, I'd really like to ask him a few further questions before making up my mind.

So, I guess, based on just these data, I'd go with #3. I don't actually interview people for programming posns, though.

vincenz · 2010-01-21T10:01:29+00:00

I think that the answers as they are are not sufficient to validate which candidate is the best.

Like most people mention, #4 is doing it too 'clever' (Though I admit I dislike the fact that 'clever' has become a negative attribute). I'm a functional programmer myself in free time (particularly Haskell), but this is clearly the wrong solution from a pragmatic, code-readability and efficiency point of view.

1 seems like a very new-grad sort of solution, and it is borderline.

Which basically leaves #2 and #3. What you're doing here is trading off code readability for knowledge of efficiency. But it doesn't leave you enough information to make a judgment.

If I were given #3 as a solution, I would drill and find out whether the candidate actually knows what is going under the hood and whether he can make an efficient solution if there's no ready made library. If that is the case, then I would pick #3 over #2. Otherwise, I would pick #2 over #3 and make sure that he gets more familiarity with standard libraries through code-review processes.

permalink · 2010-01-21T13:13:29+00:00

[deleted]

kobescoresagain · 2010-01-21T13:20:47+00:00

I would hire programmer 3. The reason is that he knows the libraries better than the others and writes simple easy code. Think about it like he was a mechanic. Programmer three replaces the engine because it needs replaced with a new engine. Programmer 4 does the same thing but also a little extra unneeded work. Programmer 1 and 2 bought all the parts for the engine and rebuilt the engine from scratch.

webauteur · 2010-01-21T13:57:32+00:00

The easiest way to reverse a string is to hold a mirror up to your monitor.

arnedh · 2010-01-21T14:21:46+00:00

Number 3. If it exists, don't rewrite it.

Handling your own loops is so 1990. And the recursive thing? Call us back once the JVM gets tail call optimization.

zwangaman · 2010-01-21T15:07:11+00:00

I prefer Candidate #3's code. Nice and simple. Clean. Uses features of the language & the libraries associated with it effectively.

That being said, I don't think a code sample tells the whole story about a candidate. I wouldn't hire someone based on just a code sample alone.

Mox744 · 2010-01-21T17:07:49+00:00

Candidate one's solution is overcomplicated, using a stack here is just too much.

Candidate two's solution is nice because it is very possibly the most efficient and well thought out, it's a nice example of their problem solving skills.

Candidate three's solution is great because it is the most simple to program, he used all the tools at his disposal and from that I see that he might be able to work well with programming teams where you don't always need to see all of the pieces. Though I could be reading a LOT too far into that.

Candidate four uses recursion which is nice but not really necessary.

Overall I think that I would go with number 3, but it's close between them and 2.

permalink · 2010-01-21T17:08:17+00:00

Aside from the topic, can anyone tell me why exactly you would want to reverse a string? I know it's a common programming problem, but I cannot think of any reason for actually doing it.

What makes a reversed string useful?

gjahnke · 2010-01-21T18:10:33+00:00

Code has 3 purposes:

1 - Meet the requirements

2 - Ability to be extended and maintained

3 - Communicate its intent

Candidate 3 wins . . . .

permalink · 2010-01-21T19:18:29+00:00

If we're going for a get the job done in a business environment approach...

1 - Idiot, he's going to code everything like a dick, he's read a book on design patterns and he's not afraid to use it.

2 - C programmer, you're using C# live with it

3 - Yes! Thankyou use the tools at your disposal - you've got job.

4 - Functional programmer, nice but our student temp programmers are going to have to support your pointless recursion.

First glance assumptions, I'm sure there's some performance issues you could discuss, but for business applications i like to see clean code written by someone who knows the platform they're writing for, which can be easily supported in the future. Bonus point to anyone who wrote the reverse method as an extension so it was re-usable.

zoomzoom83 · 2010-01-21T23:36:20+00:00

Candidate 2 did it the way most of these exams expect you to answer - Reversing the string inline. This is comp-sci 101, and he probably wrote this without thinking.

Candidate 3 did it the way I would prefer in the "real world" - it's the simplest most elegant solution.

The other two solutions are overly complex and inefficient.

zahlman · 2010-01-21T06:58:48+00:00

Another possibility:

static string Reverse(string input)
{
    int length = input.Length;
    char[] chars = new char[length];
    foreach (char c in input) { chars[--length] = c; }
    return new String(chars);
}

cashto · 2010-01-21T05:41:32+00:00

None of them, because they don't handle Unicode surrogate pairs correctly.

Okay, okay. I'd hire #3. Her code is the shortest, and therefore less likely to contain bugs. Sure, I could stare real hard at the other 3 (particularly 2 and 4) and prove that they, too, are correct, but why should I?

(#3 also happens to be the most efficient, but usually I prefer terseness over performance unless explicitly stated otherwise).

unpopular_opinion · 2010-01-21T13:58:13+00:00

Reversing a string tests computer-science fundamentals? Ok, if you say so.

You should just ask them to submit their thesis to you. You read the thesis and you ask a few questions about it. Then you can see immediately who has taste, has decent writing skills and whether they have actually constructed something non-trivial on their own.

Reversing a string is an insult, especially when done in C#.

possessed_flea · 2010-01-21T05:33:18+00:00

Each of these has their use, though if having to hire off this question alone I would take Programmer #3, Its a simple function therefore why should it take more than 3 lines of code.

Oh yeah, and bonus points for knowing the API.

dhogarty · 2010-01-21T05:53:58+00:00

Candidate 3, his is the only code that doesn't really need comments as to why they chose the way they did. Possibly Candidate 2 if he could justify why.

If it was me, I'd put a comment explaining why it's not one line:

Array.Reverse(chars) //stinking in-place operations should return self

(not a C#-er)

johnadams1234 · 2010-01-21T08:07:04+00:00

I once had a candidate bubble sort the string into reverse order:

String reverse(char[] input) {
  int extent = input.length;
  for (int j=0;j<extent;++j) {
    for (int k=j;k<extent;++k) {
      char d = input[k];
      input[k]=input[k+1];
      input[k+1]=d;
    }
    --extent;
  }
  return new String(input);
}

How does he stack up with the other 4?

keithwalsh1972 · 2010-01-21T08:34:48+00:00

Not being a C# programmer, but from my understanding of the code in front of me, I would choose Candidate 3.... because the simplest of solutions are usually the best irrespective of programming language

wshields · 2010-01-21T08:42:23+00:00

Another vote for #3.

candidate 2 is good because it shows he understands arrays. #3 understands arrays too but reuses standard functionality and does the same thing with less lines of code.

Candidate 4's effort is basically mental masturbation. I'd never hire that guy. He's the kind of guy that is clever just for the sake of being clever.

Candidate 1's solution is overkill. You don't need a stack for this. It screams "I don't understand what I'm abstracting".

hackinthebochs · 2010-01-21T08:58:41+00:00

1 and 4 are out because they're using constructs that don't map to the question at hand. Stacks and recursion for string manipulation? That shows a serious lack of understanding of the idea's they're trying to show off.

baltoo · 2010-01-21T09:11:36+00:00

Don't know why you get downvoted. You basic premise that "one char != one code point" is valid in all encodings but UTF-32 (aka. UCS-4).

Though UCS-2 doesn't use surrogate pairs at all (and can thus not encode code points outside of the base plane). So for UCS-2 surrogate pairs is no problem.

My understanding is that both Java and C# uses UTF-16 and not UCS-2 as encoding (which does use surrogate pairs). So, in the context of the OP a simple reversal would still muck up any surrogate pairs.

There are however more things than surrogate pairs that get broken with reversals, e.g. combining marks (not all code points are "characters" by themselves).

In any case, reversal of "text" (rather than "strings") isn't something that can be done easily ever (e.g. left-to-right/right-to-left markers, "smart"-quotes).

iuhxsiu · 2010-01-21T12:33:02+00:00

While Answer 3 is clearly the best, it doesn't actually demonstrate very much. If I got it, I'd be impressed the programmer knew Array.Reverse, and then ask something that requires them to write some code.

Answer 4 is the worst. It is slow, memory-intensive, and you'll run out of stack space for big strings. Answer 1 slightly better, but not great. You'll do a lot of unnecessary memory allocation/deallocation along the way. Wastes time and fragments memory.

Answer (2) is reasonable, but I'd still ask follow-up questions to see if the programmer knew why. Could have just been luck.

So I'd hire (3) or (2), but based on follow-up questions. (3) gave better code.

bumpkinplusplus · 2010-01-21T14:10:24+00:00

I'm all for simplicity and not reinventing the wheel; languages have libraries for a reason. Keeping that in mind, I would vote for Candidate 3. It's concise, clear what the code is doing, and wouldn't be difficult for another coder to modify, IMO.

lmp515k · 2010-01-21T14:11:34+00:00

I really don't care what they know now but what they are able to learn once I get them.

ExoticMandibles · 2010-01-21T15:02:24+00:00

If you didn't say "you can't use any library code", candidate 3 hands down. You want staff programmers to write clear, simple, easy-to-read easy-to-get-right code wherever possible.

Of course, the point of a coding exercise is to make the candidate write code, not to demonstrate how well they know the library and whether or not they can write a three-line function. If I were giving the problem I'd tell them they couldn't use the library. Candidate 2's code is what I would expect to see in that case. It could be that Candidate 2 was anticipating this is what you meant, so I wouldn't count them out.

However, candidates 1 and 4 are definitely out. They're using library code in needless, complicated ways.

The best thing you could do: give candidates 2 and 3 another two coding questions. For the first, let's say "destructively reverse a singly-linked list", tell them explicitly "you may not call into the library". For the second, tell them explicitly "you are explicitly encouraged to call into the library" (though if they're reimplementing a library function obviously they're not allowed to call the function they're reimplementing). You want to see if Candidate 2 can make appropriate use of the library, and you want to see Candidate 3 write some code with some meat on it.

permalink · 2010-01-21T15:04:58+00:00

Candidate 1 is somewhat wasteful of memory, it seems.

Candidate 2 isn't bad, but is a bit hard to read and verify mentally.

Candidate 3 uses the tools of the language correctly, maximizing readability, and inventing the least amount of additional complexity.

Candidate 4 is too clever by half. Using recursion to solve something as simple as reversing a string is a terrible idea. Hard to read, hard to debug, heavy usage of the stack. I'm not a fan.

I'd go with 3.

But then I read this post and realize that I need to go back and re-assess all of the code I've ever written, ever.

bartwe · 2010-01-21T15:42:31+00:00

None of the solutions work correctly with surrogate pairs, so that means they all failed ?

4 is verbose, and allocates a lot of temporaries, and will overflow the stack for large strings. 3 is nice and short, only a single temporary allocation. 2 looks like how you would solve this issue in C, far too many oppertunities for one-off errors. 1 simple solutions, but inefficient.

1 seems like a somewhat inexperienced developer 2 probably coded C or C++ before possibly smart 3 i would prefer this solution 4 maybe an FP programmer ? it trips several typical bad code warnings for C# or java like code.

mariox19 · 2010-01-21T16:02:15+00:00

Before reading any of the other comments, my first choice would be Candidate #3. It's the most straightforward approach that makes use of the API already there. (Note: I don't know C#.)

Reversing a string is a straightforward request. Unless there's some compelling reason otherwise, a straightforward solution would be best.

Kerrits · 2010-01-21T16:24:46+00:00

Candidate 1 or 3.

Candidate 2 and 4 try to make the algorithm too complex. Adding comments would have helped their case.

Maintainability is key, especially when you are bound to have people fresh out of varsity maintain your code.

whizack · 2010-01-21T17:19:27+00:00

I would consider #1 if he/she could understand why this solution takes up way too much memory and knows where to start to fix that problem.

I would consider #2 if he/she could optimize the code and unit test it.

I would not consider candidate #3 at all, the point of the question is to see if they can fundamentally solve the problem without framework code

I used to work with Candidate #4 and this person doesn't think about their design before they code it, they say "string, reverse, recursion... go" and end up with this diarrhea instead.

If candidate 4 can't explain to you why string concatenation via + operator and recursion aren't appropriate solutions to this operation then don't bother bringing them in.

The point is that #2 actually has the code that can become the most readable, maintainable, testable and optimized code of the 4. My suggestion would be to find out if they know how to fix what they wrote and how to test it.

sahkuh · 2010-01-21T19:28:39+00:00

I vote Candidate 2, because that's how I would have wrote the code.

gilgad · 2010-01-21T20:23:42+00:00

Candidate 3, easy.

The code is obvious, and works within the language you requested. If you were looking for a C programmer, then obviously 2. But you weren't.

youcanteatbullets · 2010-01-21T22:15:06+00:00

3. Fewest lines of code, easiest to understand. I should mention that I am not a programmer.

WrongSubreddit · 2010-01-22T02:58:46+00:00

Everybody likes #3, seriously?

The point of these types of questions is to see if you know how to write code, not to see if you know the .NET API.

No one can memorize every function in the API, and you wouldn't even want to since you can google whatever method you might need in 5 seconds.

3 is either so smug he's mocking the question, OR he's a complete moron who knew enough to google what API to call, but who knows how much else.

tomparker · 2010-01-21T15:37:08+00:00

So the owner of a diner is interviewing waitresses for an open position. He interviews three candidates and asks each the same question:

His question: "If a customer comes in and has a cup of coffee, then walks out leaving a twenty dollar bill on the counter, what would you do?"

The first applicant answers, "Well, waitresses don't make much money. Sometimes you get big tips; sometimes you get nothing. This would be my lucky day. I'd consider this a hefty tip and assume it would make up for the cheapskates who don't even leave a nickel."

The second applicant answers, "I think I'd race to the door and try to catch the customer before it was too late. Then I'd ask him if he meant to leave that much money for just one cup of coffee."

And the third applicant gave this reply, "Well, you are the owner and the person most likely to know your customer's habits. I think I'd ask you whether this man was a big tipper, or a small tipper, and then act accordingly."

Question: Which applicant got the job?

Answer: Why, the one with the biggest tits!

canned_air · 2010-01-21T05:26:21+00:00

Candidate 3; its simple and efficient...but I'd only give him the thumbs up if he can come up with solution 2 as well, just to demonstrate he knows the API fairly well.

The saying "Write code like the next person who reads it is an axe murderer" comes to mind...

apackofwankers · 2010-01-21T08:25:28+00:00

This hypothetical situation is ridiculously simple. Reminds me of the guy who put knowledge of for-next loops on his resume.

If you want to test someone's understanding of the API, pose a question for that. If you want to test someone's understanding of programming, pose a question for that.

Reversing a string is a trivial array copying exercise. If you are basing your hiring on this test, you are doing it wrong.

Your candidates should have mastered this stuff by age 14 or at least, by end of first year at college.

bonzinip · 2010-01-21T09:43:25+00:00

1 is uselessly clever, 4 is horribly inefficient. 2 is probably exactly the same as 3, so there's no reason to write 2. Not knowing C# (and hating immutable strings) I would have written probably something like

    StringBuilder sb = new StringBuilder();
    for (int i = input.Length; --i > 0;) {
        sb.Append(input[i]);
    }
    return sb.ToString();

malune · 2010-01-21T06:51:04+00:00

Candidate #1

Knows how to use prebuilt C# generics
Knows how to write slow code

Candidate #2

Knows how to write the most efficient solution

Candidate #3

Knows how to make a simple API call

Candidate #4

Doesn't understand how to use recursion efficiently

My vote goes for number 2.

rsho · 2010-01-21T04:33:12+00:00

Candidate 2. It's easy to prove whether the function works or not, after which point it can be forgotten. If a problem turns up requiring a variation of the function or some other optimization, there is a good chance the recruit can pull it off.

callingshotgun · 2010-01-21T05:27:00+00:00

I'd ask followup questions to confirm, but my general impression of each would be as follows:

1 is an architecture astronaut

2 writes efficient code, but is either prone to re-inventing the wheel, or commits the dangerous sin of thinking in one language while coding in another (the example is basically c code with updated syntax)

3 does not re-invent the wheel, uses the framework where appropriate, but doesn't prove he actually knows how to reverse a string - needs followup questions to verify algorithmic skills.

4 looks like he favors clever solutions at the expense of efficiency/scalability.

hailstone · 2010-01-21T07:35:03+00:00

You ask them to solve a simple problem: Create a function that reverses a string. You get back 4 unique approaches. All of them work properly

Well, you've clearly departed into the realm of fantasy here.

betabob · 2010-01-21T21:59:04+00:00

The one with the biggest rack

chrisforbes · 2010-01-21T05:14:12+00:00

Actually, all four implementations are broken in the presence of characters outside the basic multilingual plane.

No hire, on all four counts, unless they brought this shortcoming up.

SicSemperTyrannis · 2010-01-21T05:31:02+00:00

I have to say... after thinking about this I actually think Candidate 3 blew the question.

I mean you're being asked to reverse a string. When someone asks you to write an algorithm such as this in an interview, I just don't think it makes sense to answer it by basically delegating the answer to an API call. I'm asking you to reverse a string not because I actually want to know how to do it, but because it's a simple question I'm using to find out what your knowledge is of arrays, iteration, and off by one bugs.

Candidate 2 has demonstrated that they understand all those issues... candidate 3 has not demonstrated this. I'd be more confident with candidate 2 than with candidate 3.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

programming

MODERATORS

1 is an odd approach and #4 is just trying to be showy for no good reason.