only one pair of parenthsis are in the string and they are balanced, i cannot use methods which internally use for loops like contain, etc and regular expressions are prohibited.
Here is the code that i came up with but it always shows error.
public static String getParenthesis(String str) {
int first = 1 , last = str.length()-2;
if(str.charAt(0) =='(')
{
first = 0;
}
if (str.charAt(str.length()-1) == ')')
last++;
if(str.charAt(str.length()-1) == ')'&& str.charAt(0)=='(')
return str;
return getParenthesis(str.substring(first, last));
}*/
So, for example, given an input string:
Paren(thesis)String
you want to print:
thesis
Lets view this string as a character array and introduce two indices: first and size.
first size (== str.length())
| |_
str: P a r e n ( t h e s i s ) S t r i n g |_|
You want to increment first until you reach the left brace - (.
You want to decrement size until you reach the right brace - ).
The rest is just proper management of indices to satisfy String's substring().
public static String getParenthesis(String str) {
int first = 0, size = str.length();
if (str.charAt(first) != '(')
return getParenthesis(str.substring(first + 1, size));
if (str.charAt(size - 1) != ')')
return getParenthesis(str.substring(first, size - 1));
return str.substring(first + 1, size - 1);
}
To make recursive functions works properly, you need to use extra parameters, but usually you don't want to handle with that in your public function, so you could fix that using another function. Your public function will not be recursive while your private function will be.
public class HelloWorld {
private static String getParenthesisRec(String str, String res, boolean parenthesisFound) {
if (str.length() == 0) {
// Just in case...
return "";
}
char currentChar = str.charAt(0);
if (parenthesisFound && currentChar == ')') {
// Gotcha!
return res;
} else if (parenthesisFound && currentChar != ')') {
res += currentChar;
}
String substring = str.substring(1, str.length());
if (currentChar == '(') {
return HelloWorld.getParenthesisRec(substring, "", true);
}
return HelloWorld.getParenthesisRec(substring, res, parenthesisFound);
}
public static String getParenthesis(String str) {
return HelloWorld.getParenthesisRec(str, "", false);
}
public static void main(String []args) {
System.out.println(HelloWorld.getParenthesis("Example t(o StackOver)flow"));
}
}
As you can see, I just use the public getParenthesis to setup my recursive and private function getParenthesisRec. Again, you could use one single function with extra parameters, but that would be a mess because you must ensure the first call you pass the correct first values to that parameters. This isn't necessary in languages like Python where you can set default values to your parameters, but in Java you can't (you shouldn't do it though, because again, you can mess it setting incorrect values in the first call).
The question is pretty self explanatory...Design a method called startChar(String str, char c). This is a code i found here but it insert char at the end of the String. I am at a loss to think recursively. I understand this code but dont understand it enough to manipulate it to place chars at the start. Help of any kind is appreciated.
Example Input:
startChar("Apple",'p')
Output:
ppale
The code
public static String chrToLast(String str, char ch) {
//This if statement details the end condition
if(str.length() < 1) {
return "";
}
String newString = str.substring(1); //Create new string without first
character
if(str.indexOf(ch) == 0) { //This happens when your character is found
return chrToLast(newString, ch) + ch;
} else { //This happens with all other characters
return str.charAt(0) + chrToLast(newString, ch);
}
}
What about...
public static void main(String[] args) {
String s = startChar("Apple", 'p');
System.out.println("");
}
public static String startChar(String str, char ch) {
return startChar(str,ch,"","");
}
private static String startChar(String str, char ch, String acc, String chs) {
//This if statement details the end condition
if (str.length() < 1) {
return chs + acc;
}
String newString = str.substring(1); //Create new string without first character
if(str.charAt(0) == ch) { //This happens when your character is found
return startChar(newString, ch,acc, chs + ch);
} else { //This happens with all other characters
return startChar(newString, ch,acc+str.charAt(0), chs);
}
}
This is recursive with a auxiliary function
UPDATE: you must know/remember that you can procesate your data before and after the recursive call, but try to write your recursive call at the end, generally most languages has optimization in that case.
In this example we use an accumulator to accumulate processed data, then in the base step we processed those accumulator to the final output.
I am trying to write a recursion where a word is trying mirror itself (appleelppa). MY thought process is to with a recursion that prints out the word in reverse order and then add the word in the beginning. However, this did not work somehow. here is my code,
public static String reverse(String str) {
if ((null == str) || (str.length() <= 1)) {
return str;
}
return str + reverse(str.substring(1)) + str.charAt(0);
}
this is the output: ellepplepppleaapple
Any help?
Thanks
Your reverse routine is almost correct (but you really should add a mirror routine, your method is confused as is). You want something like this,
// Reverse the input String str.
private static String reverse(String str) {
// This just looked ugly.
if (str == null || str.length() <= 1) {
return str;
}
// this is how you recursively reverse the word.
return reverse(str.substring(1)) + str.charAt(0);
}
// mirror is trivial, the word and the reverse of the word.
public static String mirror(String str) {
return str + reverse(str);
}
public static void main(String[] args) {
String str = "apple";
System.out.println(mirror(str));
}
Output is (as requested)
appleelppa
EDIT
// mirror an input string iteratively.
public static String mirror(String str) {
// return str + reverse(str);
StringBuilder sb = new StringBuilder(str);
return str + sb.reverse().toString();
}
All the answers you were given gave you new solutions. I'm here to tell you your solution is 90% correct.
Remove str + from:
return str + reverse(str.substring(1)) + str.charAt(0);
To make:
return reverse(str.substring(1)) + str.charAt(0);
And your original function works like a charm ;)
It would be much simpler if you just wrote a recursive function to reverse the string, and then added it to the original.
public class Reverse{
public static String reverse(String str) {
if ((null == str) || (str.length() <= 1)) {
return str;
}
return reverse(str.substring(1)) + str.charAt(0);
}
public static void main(String[] args) {
System.out.println("appleelppa" + reverse("appleelppa"));
}
}
The ugly hack to use exactly how one method with recursion and not iteration.
Note that this is not the preferred way to do things. It is only placed here to show the OP that it can be done, since he was curious. This is inspired by a comment from AdrianShum.
public class Reverse{
public static String mirror(String str, boolean firstCall) {
if ((null == str) || (str.length() <= 1)) {
return str;
}
if (firstCall)
return str + mirror(str.substring(1), false) + str.charAt(0);
else
return mirror(str.substring(1),false) + str.charAt(0);
}
public static void main(String[] args) {
System.out.println(mirror("appleelppa", true));
}
}
Another not ugly recursive approach:
public static String mirror(String s) {
if (s == null || s.isEmpty()) {
return "";
}
return s.charAt(0) + mirror(s.substring(1)) + s.charAt(0);
}
In brief, mirroring a string means having a string with the first character, then the mirrored remainings, and then the first character again.
(Edit: just updated with actual code that I have tested which works)
I have been messing around with recursion today. Often a programming technique that is not used enough.
I set out to recursively reverse a string. Here's what I came up with:
//A method to reverse a string using recursion
public String reverseString(String s){
char c = s.charAt(s.length()-1);
if(s.length() == 1) return Character.toString(c);
return c + reverseString(s.substring(0,s.length()-1));
}
My question: is there a better way in Java?
The best way is not to use recursion. These stuff are usually used to teach students the recursion concept, not actual best practices. So the way you're doing it is just fine. Just don't use recursion in Java for these kind of stuff in real world apps ;)
PS. Aside what I just said, I'd choose "" as the base case of my recursive function:
public String reverseString(String s){
if (s.length() == 0)
return s;
return reverseString(s.substring(1)) + s.charAt(0);
}
If you're going to do this, you want to operate on a character array, because a String is immutable and you're going to be copying Strings all over the place if you do it that way.
This is untested and totally stream of consciousness. It probably has an OB1 somewhere. And very not-Java.
public String reverseString(String s)
{
char[] cstr = s.getChars();
reverseCStr(cstr, 0, s.length - 1);
return new String(cstr);
}
/**
* Reverse a character array in place.
*/
private void reverseCStr(char[] a, int s, int e)
{
// This is the middle of the array; we're done.
if (e - s <= 0)
return;
char t = a[s];
a[s] = a[e];
a[e] = t;
reverseCStr(a, s + 1, e - 1);
}
You don't want to nest too deeply. Divide-and-conquer is the way to go. Also reduces total size of temporary strings and is amenable to parallelisation.
public static String reverseString(String str) {
int len = str.length();
return len<=1 ? str : (
reverseString(str.substring(len/2))+
reverseString(str.substring(0, len/2))
);
}
(Not tested - this is stackoverflow.)
String.concat instead of + would improve performance at the expense of clarity.
Edit: Just for fun, a tail-recursion friendly version of the naive algorithm.
public static String reverseString(String str) {
return reverseString("", str);
}
private static String reverseString(String reversed, String forward) {
return forward.equals("") ? reversed : (
reverseString(reversed+forward.charAt(0), forward.substring(1))
);
}
Correct handling of surrogate pairs is left to the interested reader.
here is my recursive reverse function that is working fine
public static String rev(String instr){
if(instr.length()<=1){
return instr;
} else {
return (instr.charAt(instr.length()-1)+rev(instr.substring(0,instr.length()-1)) );
}
}
Just for the heck of it, here's a tail-recursive method using StringBuilder (which is generally recommended over manipulating Strings).
public String reverseString(String s_) {
StringBuilder r = new StringBuilder();
StringBuilder s = new StringBuilder(s_);
r = reverseStringHelper(r, s);
return r.toString();
}
private StringBuilder reverseStringHelper(StringBuilder r, StringBuilder s) {
if (s.length() == 0)
return r;
else
return reverseStringHelper(r.append(s.charAt(0)), s.deleteCharAt(0));
}
Untested, I haven't dealt with Java in many years, but this should be about right.
If you're writing real code (not learning recursion), use StringBuilder's reverse() method. The Java Tutorial gives this example:
String palindrome = "Dot saw I was Tod";
StringBuilder sb = new StringBuilder(palindrome);
sb.reverse(); // reverse it
System.out.println(sb);
It depends on what you define as "better". :-) Seriously, though; your solution essentially uses the maximum depth of recursion; if stack size is of a concern for your definition of "better", then you'd be better off using something like this:
public String reverseString(String s) {
if (s.length() == 1) return s;
return reverseString(s.substring(s.length() / 2, s.length() -1) + reverseString(0, s.length() / 2);
}
This is what I've found to work and use recursive. You can pass str.length() as strLength argument
private static String reverse(String str, int strLength) {
String result = "";
if(strLength > 0)
result = str.charAt(strLength - 1) + reverse(str, strLength - 1);
return result;
}
In Java, since the String is immutable, the String concatenation would be more complex than it looks like.
For every concatenation, it creates a new string copying the contents of original String resulting in a linear complexity O(n) where n is the length of the string, so for m such operations it is O(m*n), we can say it is of quadratic complexity O(n^2).
We can use a StringBuilder which has O(1) complexity for each append. Below is the recursive program using StringBuilder. This uses only n/2 stack frames, so it has less space complexity than the normal recursive call which would be like s.charAt(s.length-1) + reverse(s.subString(0, s.length-2);
public class StringReverseRecursive {
public static void main(String[] args) {
String s = "lasrever gnirts fo noitatnemelpmi evisrucer a si sihT";
StringBuilder sb = new StringBuilder(s);
reverse(s, sb, 0, sb.length() - 1);
System.out.println(sb.toString());
}
public static void reverse(String s, StringBuilder sb, int low, int high) {
if (low > high)
return;
sb.setCharAt(low, s.charAt(high));
sb.setCharAt(high, s.charAt(low));
reverse(s, sb, ++low, --high);
}
}
That's definitely how I'd go about recursively reversing a string (although it might be nice to extend it to the case of an empty string in your condition.) I don't think there is any fundamentally better way.
EDIT: It may be more efficient to operate on a character array and pass a "cutoff" length down the chain of recursion, if you get my drift, rather than making substrings. However, this is not really worth nitpicking about, since it's not a terribly efficient technique in the first place.
You capture the basic idea, but extracting the last character doesn't improve clarity. I'd prefer the following, others might not:
public class Foo
{
public static void main(String[] argv) throws Exception
{
System.out.println(reverse("a"));
System.out.println(reverse("ab"));
System.out.println(reverse("abc"));
}
public final static String reverse(String s)
{
// oft-repeated call, so reduce clutter with var
int length = s.length();
if (length <= 1)
return s;
else
return s.substring(length - 1) + reverse(s.substring(0, length - 1));
}
}
As Mehrdad noted, it's best not to use recursion. If you do use it, though, you might as well keep both the first and last character each call, thus halving the number of recursive calls. That is,
public String reverseString(String s){
int len = s.length();
if (len <= 1) {
return s;
}
char fst = s.charAt(0);
char lst = s.charAt(len - 1);
return lst + reverseString(s.substring(1, len - 2)) + fst;
}
This also handles the case of the empty string. Perhaps passing along a StringBuilder with the appropriate capacity would speed things up even more, but that's left as an exercise to the reader ;)
You can try with an external variable, and add 1 by 1 all chars:
public static String back="";
public static String reverseString(String str){
if(str.length()==0){
return back;
}else {
back+=str.charAt(str.length()-1);
lees(str.substring(0,str.length()-1));
return back;
}
}
Here is my immutable version:
String reverse(String str) {
if(str.length()<2) return str;
return reverse(str.substring(1)) +str.charAt(0);
}
and tail recursive version:
String reverseTail(String str) {
if(str.length()<2) return str;
return str.charAt(str.length()-1)+ reverseTail(str.substring(0,str.length()-1));
In this context, this is totally unnecessary, but you can simulate recursion and avoid recursion depth issues if you make your own stack.
You can iterative implement recursion, which may be necessary when you have algorithms which are inherently recursive, but also need to run them for big problem sizes.
String recIterReverse (String word){
Stack <String> stack = new Stack <String> ();
stack.push(word);
String result = "";
while (!stack.isEmpty()){
String temp = stack.pop();
result = temp.charAt(0) + result;
if (temp.length() > 1){
stack.push(temp.substring(1));
}
}
return result;
}
function call:
//str:string to be reversed,i=0,j=str.length-1
public void reverseString(String str,int i,int j)
{
if(i==j)
{
System.out.println(str);
return;
}
char x=str.charAt(i);
str=str.replace(str.charAt(i),str.charAt(j));
str=str.replace(str.charAt(j),x);
i++;j--;
reverseString(str,i,j);
}
this method works too..
Try the following:
public class reverse2
{
public static void main(String name)
{
String revname=new StringBuffer(name).reverse().toString();
System.out.println("original string " + name + " and the reverse of it is " + revname);
}
}
public static String rev(String name){
if(name.length()>=1){
System.out.print(name.charAt(name.length()-1));
return rev(name.substring(0,name.length()-1));
}
else{
return ""+name.substring(0);
}
}
String rev="";
public String reverseString(String s){
if (s.length()==0) return "";
return rev+s.substring(s.length()-1,s.length())+reverseString(s.substring(0, s.length()-1));
}
public String reverseString (String s) {
if (s != null && s.length () > 0 ) {
rev = rev + s.substring (s.length () - 1);
reverseString (s.substring (0, s.length () - 1));
}
return rev;
}
public class StringUtility {
public static void main(String[] args) {
StringUtility stringUtility = new StringUtility();
String input = "santosh123";
int middle = input.length() / 2;
middle = middle - 1;
System.out.println(stringUtility.stringReverse(input, middle));
}
public String stringReverse(String input, int middle) {
if (middle == -1) {
System.out.println("if");
return input;
} else {
System.out.println("else");
input = swapChar(input, middle);
middle = middle - 1;
return stringReverse(input, middle);
}
}
private String swapChar(String input, int middle) {
StringBuilder str = new StringBuilder(input);
char begin = str.charAt(middle);
int endIndex = input.length() - middle - 1;
char end = str.charAt(endIndex);
str.setCharAt(middle, end);
str.setCharAt(endIndex, begin);
System.out.println(str + " " + middle + " " + endIndex);
return str.toString();
}
}
If you think less code is good then....
static String reverse(String str){
return str.length()>=2 ? str.charAt(str.length()-1) + reverse(str.substring(0,str.length()-1)) : str ;
}
There are about 20 answers already but I'll just throw in my recursive algorithm as well. It may be a little verbose but it is at least readable.
public static String reverseString(String str) {
return reverseString("", str);
}
private static String reverseString(String result, String original) {
if (original.length() == 0) {
return result;
} else {
int length = original.length();
String lastLetter = original.substring(length - 1, length);
original = original.substring(0, length - 1);
return reverseString(result + lastLetter, original);
}
}
The code basically recursively takes the end of the string and moves it in front. For example if the string we want to reverse is "jam," then each time the helper method is called, result and original strings are as follows:
// result: original:
// "" jam
// m ja
// ma j
// maj ""
Reverse String using the recursive method call.
Sample Code
public static String reverseString(String s) {
if (s.length() == 0) {
return s;
}
else {
return s.charAt(s.length() - 1) + reverseString(s.substring(0, s.length() - 1));
}
}
This is my solution,I saw in many solutions above we are getting the string length but ideally we don't need that. The Zen is to use recursion, just chop the first char of string and pass the rest to recursive method. Yay!! we got the solution.
private static void printReverse(String str) {
if (!str.isEmpty()) {
String firstChar = str.substring(0, 1); //Get first char of String
String newstr = str.substring(0, 0) + str.substring(1); // Get remaining string
printReverse(newstr); // Recursion magic
System.out.print(firstChar); //Output
}
}
public static String reverse(String s){
int n = s.length()-1;
if(n >=0)
return s.substring(s.length()-1)+ReverseString(s.substring(0,n--));
else return "";
}