CareerCup

public String reverse(String str){
if(str == null || s.length()<=1)
return str;
return (reverse(str.subString(1))+str.charAt(0);
}

public static class MyAlgorithms 
{
    public static void Reverse(char[] s, int startIndex, int endIndex) 
    {
        if (startIndex >= endIndex)
        {
           return;
        }

        var firstLetter = s[startIndex];
        var lastLetter = s[endIndex];
        s[startIndex] = lastLetter;
        s[endIndex] = firstLetter;
        Reverse(s, ++startIndex, --endIndex);
    }
}

String in java are immutable, it doesn't make sense to create a new copy of the string at every recursion.

Try:

public class Reverse {

  public static String recursiveStringReverse(String input) {
    return recursiveStringReverse(input.toCharArray(), 0, input.length()-1);
  }
  public static String recursiveStringReverse(char[] input, int first, int last) {
  if(first >= last) {
    return new String(input);
  } else {
    char temp = input[first];
    input[first] = input[last];
    input[last] = temp;
    return recursiveStringReverse(input, first+1, last-1);
  }
  }

  public static void main(String[] args) {
    System.out.println(Reverse.recursiveStringReverse("input"));
  }
}

public class ReverseStringUsingRecursion {

static StringBuilder sb=new StringBuilder();

public static void main(String[] args) {
// TODO Auto-generated method stub
String s="mrwayne";
reverseString(s,s.length());
System.out.println(sb.toString());

}

private static void reverseString(String str,int length)
{
if(length==0)
return;
sb.append(str.charAt(--length));
reverseString(str, length);

}

}

public static string Reverse(string s)
{
	if (string.IsNullOrEmpty(s))
		return s;
	
	var sb = new StringBuilder();
	Reverse(s, sb, 0);
	return sb.ToString();
}

private static void Reverse(string s, StringBuilder sb, int index)
{
	if (index == s.Length)
		return;
	
	Reverse(s, sb, index+1);
	sb.Append(s[index]);
}

public static void Recursion(String s){
		String rev = Recursion(s, "", s.length()-1);
		System.out.println(rev);
	}
	public static String Recursion(String s, String rev, int index){
		if(index < 0 )
			return rev;
		
		return Recursion(s, rev+s.charAt(index), index-1);
	}

public static void Recursion(String s){
		String rev = Recursion(s, "", s.length()-1);
		System.out.println(rev);
	}
	public static String Recursion(String s, String rev, int index){
		if(index < 0 )
			return rev;
		
		return Recursion(s, rev+s.charAt(index), index-1);
	}

void SwapAndMoveToTheMiddle(char* pA, char* pB)
{
	char cTemp;

	if (pA >= pB) return;

	cTemp = *pA;
	*pA = *pB;
	*pB = cTemp;
	++pA;
	--pB;
	SwapAndMoveToTheMiddle(pA, pB);
}
//.............................................................................................................
void ReverseStringWithRecursion(char* pOurString)
{
	char *pBegin, *pEnd;

	pBegin = pOurString;
	while (*pOurString)
		++pBegin;
	pEnd = pBegin;
	pBegin = pOurString;

	SwapAndMoveToTheMiddle(pBegin, pEnd);
}

string reverse(string s, int k){
	if(k>=s.size()/2){
		return s;
	}
	char tmp = s[k];
	s[k] = s[s.size()-k-1];
	s[s.size()-k-1] = tmp;
	return reverse(s, k+1);
}

public class StringReverseRecursion {


public static char[] Reverse(int start,int end,char[] temp,String s)
{
if(start>=end)
{
if(start==end)
{
temp[start]=s.charAt(end);
}
return temp;
}
temp[end]=s.charAt(start);
temp[start]=s.charAt(end);
return Reverse(start+1, end-1, temp, s);
}

public static void main(String[] args) {

Scanner sc=new Scanner(System.in);
String input=sc.next();
char[] array=new char[input.length()+1];
char[] result=Reverse(0, input.length()-1, array,input);
String s1=String.copyValueOf(result);
System.out.println(s1);
}

}

Swift implementation

func reverse(s:String)->String{
    var chars = Array(s.characters)
    var reversed = String()
    
    func getLastC(s:String, pos:Int)->String{
        var chars = Array(s.characters)
        reversed.append(chars[pos])
        if pos == 0{
            return String(chars[0])
        }
        return getLastC(s: s, pos: pos - 1)
    }
    getLastC(s: s, pos: s.characters.count - 1)
    return reversed
}

Swift implementation

func reverse(s:String)->String{
    var chars = Array(s.characters)
    var reversed = String()
    
    func getLastC(s:String, pos:Int)->String{
        var chars = Array(s.characters)
        reversed.append(chars[pos])
        if pos == 0{
            return String(chars[0])
        }
        return getLastC(s: s, pos: pos - 1)
    }
    getLastC(s: s, pos: s.characters.count - 1)
    return reversed
}

void reverse(char* s, int size, int i) {
    if(i >= size/2) return ;
    char c = s[i];
    s[i] = s[size-1-i];
    s[size-1-i] = c;
    reverse(s, size, ++i);
}