I found a lot interviews just starting with a lot questions. If the person happens do not know the answer, the person will fail. However, in the real life, how a person knows every thing. At work, we face a lot deadlines, we have to focus on the job. Get home, we need to take care the family.

However we have ability to solve the problem. If there is a problem, we do not know, we will google it, try the solution.

I have more that 12 years developing experience and i did a lot big projects. But I hate the interview with code and sql. I am sure that I will fail in the on site coding. If the question like this, I would think that why they ask the question is so simple and what they want to test, that makes me think too much.

In the problem like this, should check if the parameter is null or not? Should be always pessimistic, should the client to use the method to check?

Should you always remember the sql, how many people use sql every day, even once a week?

I would like always test if the person know what he/she has done.

When I interview candidates, I only asked the questions related to candidate’s work experience. I want to find out how deep a candidate understand the projects he/she worked on. I would adjust questions so I could effectively measure where is a candidate’s knowledge.

- Convert to char array using toCharArray() and iterate the for loop instead.

- charArray.length will not invoke any method since it is the atribute and not a method.

- When calling StringBuffer or its faster version as Java 1.5 “StringBulder” takes valuables resources.
We should understand that the cost involved in invoking methods are:

a) Actual transfer of the control.
b) Parameter and return values passing.
c) Establishment of stack frame for local variables.

This is a very simple an efficient solution:

public String reverseString (String str) {
if (str == null || “”.equals(str)) {
return str;
}

char[] charArray = str.toCharArray();
char[] swap = new char[charArray.length];
int len = charArray.length – 1;

for (int i = len; i >= 0; i–) {
swap[i] = charArray[len - i];
}
return new String(swap);

}

Best regards!
gabo

But even I disagree about the Recursion part. Most folks who have tons of experience hardly use recursion and are rusty with its concepts. IMO it would be bad to judge candidates based on whether they can give complex recursive solutions. But then again, you have every right to determine what you want.

import java.util.Scanner;

public class StringReverser {

public static void main (String args []){

Scanner input = new Scanner(System.in);
System.out.println(“Please enter a word: “);
String str = input.nextLine();

int value = str.length() – 1;
for(int x = value; x>=0 ; x–){
System.out.print(str.charAt(x));
}
}
}

Indeed, if people would memorize solutions and write those down, I’d rather not call them programmers.

I’d like to ask you to step back just for a minute here and try to take in the big picture of what it is you are doing and recommending to others to do as well.
You have had a countless number of hours and days to explore and implement this reversal algorithm and at the comfort of your desk. And you are calling on the interviewee to be able to reproduce the same in the span of several seconds all the while undergoing the extremely stressful and uncomfortable procedure of a job interview. Where one is judged and interrogated and is presumed to be found lacking until proven otherwise.
And in the end even if the person succeeds to have memorized the solution and fire it back to you what have you really learned about the prospect. Above you mentioned that this is not meant to be a puzzler, as you worded it, but is meant as a discussion point of further techniques. However, it does not succeed in this regard, as it has already taken an interview to completely different and I might add completely irrelevant realm. In the end and in the beginning it is simply a memorization drilling, for this technique or that with the memorization of Java API included to boot. Like Pranav I’ve been to interviews like this, and ran as fast and as far as I could from the employer.
Of course, if you are simply looking for a coder who is able to memorize things, this should land you the desired candidate but it cannot reveal the persons way of thinking or reasoning.

My question to the interviewer in response to tests like these would be to ask when the last time programmers at the company had to hand-build a string reverser, or ask them the role it plays in their development. The answer to that is a measure of the utility of the test.

If the person being interviewed graduated from a university with a computer science degree, they can “handle complex problems or several layers in their head.” How else does they get through computer science coursework?

It is random what we’re asked at interviews. You might make great decisions about how to code things you’ve done on-the-job but not do well on random things asked in an interview that you haven’t thought about in a long time.

You can study for 3 days for an important interview and then not be able to answer a question on something the interviewer randomly took off p. 325 of the manual.

In the old days,interviewing managers assumed that programmers knew how to write code and that whatever they didn’t know on the job they would simply look up. That’s why we have all those code books lined up on a shelf above our desks.

I don’t know how interviews have become just trying to trick the candidate into exposing himself as a code fraud. It does not reflect well on the manager.

First 10 Minutes:
—————–
1. Always FIRST try to understand WHAT the developer KNOWS. Do not focus on What the developer DOES NOT KNOW.

2. Make the developer TALK about things he has WORKED ON. Be Supportive.

Next 10 Minutes:
—————-
3. Ask Questions on topics THAT developer had indeed worked on.

Last 10 Minutes:
—————-
4. Ask questions on things You would like. Your pre-meditated questions should come here.

This way you do not pre-judge a candidate based on your questions. The developer feels that you did study his resume.

—-
I have attended interview where in the first 5 minutes Two puzzle/algorithm like questions were asked (Bubble Sort algorithm, 5-red balls kind of thing). Since i did not answer satisfactorily NO OTHER QUESTIONS were further asked. And i felt thoroughly cheated.

—

I have interviewed many people, found that people who are able to answer WHAT THEY WORKED ON SATISFACTORILY are usually better in the long-run, than one’s who know a few so-called-smart answers – the latter people even if smart – fail to deliver projects.

–

My lengthy two cents. :)

public String reverse(String s) {
//work outside in, swap e and a..then return inner substring
if(s != null && s.length() > 1) {
return s.charAt(s.length()-1) + reverse(s.substring(1, s.length()-1)) + s.charAt(0);
}
return s;
}

}
System.out.println(“String after reverse:”+s2);
}
}

Then pop them out. This is the best way to reverse a string.

–Edwin.

Although I know StringBuffer I have used it for appending strings. I did write a string reverser just converted the string into an array of char read the contents into another char array converted back into a String. There are quite a few ways to solve it.

But gettinh back to pranav with all the new frameworks, doing a lot of the work for you, the skill will/should be, what framework would you choose and why.

Would/why would you use ORM.

Coding to java patterns.

The problems related to mixing framworks.

There is so much java technology out there. So many different frameworks and even different versions.

Updating JAXB recently a lot of the JAXB related functions stopped working.

This happens a lot, a good interview is to ask the developer what would they do, how would they go about solving this problem or making sure the problem does not happen in the first place.

I find when I am preparing for java interviews, I need to remove my java head and put on my old C coding head.

it was a waste of time commuting all the way and not being asked a single question about my role at my current job.

you do not need to know these low level things, if you get the big picture. these kind of questions are good for college tests which have nothing to do with real world. in real life, you will never sit and reverse a string.

i hate when interviewers try to be too geeky. that’s why they have 10+ years of exp and they still are coding reporting to a non-techy person who knows nothing about computers.

public static String reverse(String toReverse) {
return reverse(toReverse, “”);
}

private static String reverse(String toReverse, String reverse) {
if (toReverse == null || reverse.length() == toReverse.length()) {
return reverse;
}
reverse += toReverse.charAt(toReverse.length() – reverse.length() – 1);
return reverse(toReverse, reverse);
}

“The best implementation in Java is to use the reverse method of the StringBuffer class in the JDK. It’s fast, efficient and knows how to handle unicode surrogate pairs, something most other solutions ignore.”

Thanks
Stephan

your solution has terrible performance characteristics.

Never do this:

for(int k=0;k0&&m>=m-1;m–){
temp=temp+” “+arr[m-1];

}

Repeated concatenation in Java is VERY SLOW. You end up doing O(N2) character copies because of the implicit StringBuilders..

The correct way to do it is:

StringBuilder temp = new StringBuilder(str.length());
for (…) {
temp.append(arr[m-1]);
}

return temp.toString();

This avoids n(n-1)/2 character copies instead of just n.

}
System.out.println(“MMMMM”+temp);
}

public static void main(String[] args) {
String str=”This. is Mruthyu”;
String temp=”";
StringTokenizer stk = new StringTokenizer(str);
String arr[] = new String[stk.countTokens()];
while(stk.hasMoreElements()){
for(int k=0;k0&&m>=m-1;m–){
temp=temp+” “+arr[m-1];

}
System.out.println(“MMMMM”+temp);
}

“The exception thrown when trying to reverse a null string should be a null pointer exception.”

I’m not certain on this one. Developers search for the cause of NPEs by looking for dots which dereference references. So throwing a NPE when there is no null pointer access doesn’t help. I also think that throwing an NPE for

int i = (Integer) null;

was a wrong decision on Suns side. A AutoUnboxingException would have been more helpful and make this error much easier to detect.

I’ve added a tail recursive version here

http://stephan.reposita.org/archives/2007/11/12/string-reversing-part-ii-tail-recursion/

In the 1.5 JDK, Sun changed the behavior of the StringBuffer.reverse() method in a way that was not backward compatible with 1.4. That is, there are StringBuffer instances for which reverse() in 1.4 returns a different value than in 1.5.

The 1.5 version of reverse() is sensitive to surrogate pairs (unicode code points requiring more than 16 bits, and hence more than one char, in UTF-16). In 1.5, both java.lang.StringBuilder and java.lang.StringBuffer use the implementation of reverse() from their common superclass, java.lang.AbstractStringBuilder.

Here’s the first paragraph of doc for java.lang.StringBuffer.reverse() from JDK 1.5:

“Causes this character sequence to be replaced by the reverse of the sequence. If there are any surrogate pairs included in the sequence, these are treated as single characters for the reverse operation. Thus, the order of the high-low surrogates is never reversed.”

And here’s the first paragraph of doc from java.lang.StringBuffer.reverse() from JDK 1.4:

“The character sequence contained in this string buffer is replaced by the reverse of the sequence.”

Following Stephan’s suggestion to use the built-in has either a good or bad side effect. Moving from 1.4 to 1.5 either breaks backward compatibility for the string as char sequence representation, or appropriately handles unicode 5.0 in the string as sequence of code points representation.

Extra credit 1: Recursion won’t work because it’ll blow out the stack if we’re using Sun’s JDKs, which (at least so far) don’t perform tail recursion optimization (a kind of last call optimization).

Extra credit 2: The exception thrown when trying to reverse a null string should be a null pointer exception. That’s how Sun codes the JDK itself (see, e.g., the java.lang.String.String(String) constructor). It’s a runtime exception because it’s a coding error to send reverse(String) a null string (assuming you want behavior like your call to StringBuffer.reverse()). It should be a null pointer exception, as that’ll lead you right to the problem while debugging.

Do I get a callback for a second interview?

Tail recursion should be best avoided , in such cases an iterative solution is much much better . Fibonacci series ( iterative vs recursion ) has been discussed a zillion times .

I feel its best to ask recursive problems that truly are recursive without being tail recursive .

But go ahead, write a tail recursive version. Which will not help, because Java does not optimize tail recursion.

Obviously one would ask the candidate about past projects, his roles in these projects, his view on technologies, testing, quality assurance, requirement engineering, his social skills and much more. Asking one programming question is only a small part of an interview process.

Gr33tZ
-stephan

On the programmers interviews though, I like to ask about their experiences in a practical sense and have them explain to me parts of projects they have worked on. Not puzzles like this one you are outlining here.

Greetz

Leo

This does not help, as the main reason for the question is the discussion on why the developer has chosen the particular solution.

So obviously I would ask a different question when interviewing Ruby developers.

Or Javascript developers.

Or Lisp developers.

Or did I missunderstand your comment and it was another “Ruby rulez Java” comment?

@Witek: Sorry for my ill informed reply.

return reverse(str.substring(1)) + str.charAt(0);

So the stack frame has to stay around to do the append on the recursive result. To make this tail recursive you need to pass in an accumulator like Witek’s solution.

@Paulo: Yes, off topic for this post, not off topic for interviewing. Asking about Open Source projects is a good idea. I would prefer a candidate who is participating in Open Source projects, good idea.

Example in Erlang:

reverse(X) ->
reverse(X, []).

reverse([A|Rest], Acc) ->
reverse(Rest, A Acc);
reverse([], Acc) ->
Acc.

This should take constant stack space.

Thanks
Prashant
http://prashantjalasutram.blogspot.com/

public class StringReverser {

static String orgStr = "prasanth";

static char[] orgCharArr = orgStr.toCharArray();

static char[] distCharArr = new char[orgStr.length()];

static int endCounter = orgCharArr.length – 1;

static int startCounter = 0;

static StringBuffer output = new StringBuffer();

public static void main(String[] args) {
String orginalString = "pras";
char[] reverseStr=reverse(orgCharArr);
System.out.println(reverseStr);
}

static char[] reverse(char[] org) {

distCharArr[endCounter]=orgCharArr[startCounter];

if(endCounter<=0 || startCounter>=orgStr.length()) {
return distCharArr;
}else {
startCounter ;
endCounter–;
return reverse(orgCharArr);
}

}}

I thought there was such a function in String and was searching for it, there I found StringBuffer.reverse.

Actually, I prefer the JDK provided methods and I definitly would have taken a look into the API before starting to code that in a real project. Relying on the JDK is one of my most-liked parts of Java.

this depends. I don’t think the java compiler can use StringBuffer for the given recursion, it’s only possible to detect easy cases of String usage currently. So

"Person: " \+ name \+  " with age: " \+  age

will be converted to a StringBuffer by the javac compiler,

 return reverse(str.substring(1)) \+  str.charAt(0);

probably not, unless the compiler or the JIT VM have some very, very smart escape analysis.

“The Java language provides special support for the string concatenation operator ( ), and for conversion of other objects to strings. String concatenation is implemented through the StringBuilder(or StringBuffer) class and its append method”