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”