JAVA FOR SCHOOL RECURSION

Making Java Fun To Learn Programs Related to Strings

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Important Note: In this note, we have just provided the main codes for doing a program by implementing
recursion and have not declared the class or written the main() method.
In order to write the complete program, you are required to first declare a class and then write the recursive
methods. An example of the code which you need to write before the methods is given below:

import java.io.*;
class Sample
{
static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

Reversing a String
Recursive Method 1 Recursive Method 2 Recursive Method 3
Without Return Type With Return Type

void rev(String s, int i) String r=""; String r="";

{ String rev(String s, int i) String rev(String s, int i)
if(i<s.length()) { {
{ if(i<s.length()) if(i>=0)
char ch=s.charAt(i); { {
rev(s,i+1); char ch=s.charAt(i); char ch=s.charAt(i);
System.out.print(ch); rev(s,i+1); r=r+ch;
} r=r+ch; rev(s,i-1);
} } }
return r; return r;
} }

void display()throws void display()throws void display()throws

IOException IOException IOException
{ { {
System.out.print("Enter any word : System.out.print("Enter any word : System.out.print("Enter a word : ");
"); "); String s=br.readLine();
String s=br.readLine(); String s=br.readLine(); int len=s.length();
System.out.print("Reverse of the String x=rev(s,0); String x=rev(s,len-1);
word = "); System.out.print("Reverse of the System.out.print("Reverse of the
rev(s,0); word = "+x); word = "+x);
} } }

Note: In some of the questions related to recursion, you will find Iterative Method
mentioned in the question that you don’t need to write the main() method.
String r="";
String rev(String s)
But, the students are advised to write the main() method after writing the
{
above recursive methods, while they are practicing the programs. The main
int i=0;
method is nothing but a few lines calling the above created methods.
while(i<s.length())
{
An example of the main method for the above program is given below.
char ch=s.charAt(i);
r=r+ch;
public static void main()throws IOException
i++;
{
}
Sample ob=new Sample();
return r;
ob.display();
}
}

Note: In the First example we are using a recursive function without any return type and we are not saving the
reverse of the String in any number. We are just printing the characters as we get them in reverse order due to
the LIFO property of the stack used in recursion.

In the 2nd and 3rd example we are using a recursive function with a return type and we are saving the reverse of
the String in an instance variable 'r' and we are returning the result at the end. The difference in the approach of
the 2nd and the 3rd method is that the 2nd method extracts characters from the beginning of the String and uses
the LIFO property of the stack used in recursion to reverse the word whereas, the 3rd method extracts characters
from the end of the String and adds this to the variable 'r' and does not utilize the LIFO property of the stack used
in recursion.

------------------------------------ © www.javaforschool.com -------------------------- Page 1 ---

JAVA FOR SCHOOL RECURSION
Making Java Fun To Learn Programs Related to Strings
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Another Recursive method Checking for Palindrome Word – ISC
String r="";
2008
String rev(String s, int i) After reversing a String using the 2nd or the 3rd method,
{ you can check whether that String is a palindrome or
if(i<s.length()) not by adding the below code in the display () function
{ after the printing of the reverse word:
char ch=s.charAt(i);
r=ch+r; void display()throws IOException
rev(s,i+1); {
} ……
return r; ……
} if(x.equals(s))
System.out.print("The word is a Palindrome");
The above method is just a slight variation of the 2nd else
method with the only difference being that we are not System.out.print("The word is Not a Palindrome");
using the LIFO property and the change: r=ch+r; }

Extracting Characters of a String and performing any given operation

Recursive Method Corresponding Iterative Method

void stringOp(String s, int i) void stringOp(String s)

{ {
if(i<s.length()) int i=0;
{ while(i<s.length())
char ch=s.charAt(i); {
char ch=s.charAt(i);
Write the operation you want to perform with
Write the operation you want to perform with
the character stored in 'ch' over here.
the character stored in 'ch' over here.
stringOp(s,i+1);
i++;
}
}
}
}

In the above code, we are extracting the characters from the beginning of the String passed as parameter.
After storing it in the variable 'ch', you write the code of the operation you want to perform with that character.
You can also send the character to another function which will perform some task with that character.

Some Programs using the above technique

1. Converting characters of a String from UpperCase to LowerCase and vice versa

Recursive Method 1 Corresponding Iterative Method

void caseConvert(String s, int i) void caseConvert(String s)

{ {
if(i<s.length()) int i=0;
{ while(i<s.length())
char ch=s.charAt(i); {
if(Character.isUpperCase(ch)) char ch=s.charAt(i);
System.out.print(Character.toLowerCase(ch)); if(Character.isUpperCase(ch))
else System.out.print(Character.toLowerCase(ch));
System.out.print(Character.toUpperCase(ch)); else
caseConvert(s,i+1); System.out.print(Character.toUpperCase(ch));
} i++;
} }}
void display()throws IOException void display()throws IOException
{ {
System.out.print("Enter any String : "); System.out.print("Enter any String : ");
String s=br.readLine(); String s=br.readLine();
System.out.print("The new String = "); System.out.print("The new String = ");
ob.caseConvert(s,0); ob.caseConvert(s);
} }

------------------------------------ © www.javaforschool.com -------------------------- Page 2 ---

JAVA FOR SCHOOL RECURSION
Making Java Fun To Learn Programs Related to Strings
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Recursive Method 2 Corresponding Iterative Method

String newstr=""; String newstr=""; int i=0;

String caseConvert(String s, int i) String caseConvert(String s)
{ {
if(i<s.length()) while(i<s.length())
{ {
char ch=s.charAt(i); char ch=s.charAt(i);
if(Character.isUpperCase(ch)) if(Character.isUpperCase(ch))
ch=Character.toLowerCase(ch); ch=Character.toLowerCase(ch);
else else
ch=Character.toUpperCase(ch); ch=Character.toUpperCase(ch);
newstr=newstr+ch; newstr=newstr+ch;
caseConvert(s,i+1); i++;
} }
return newstr; return newstr;
} }
void display()throws IOException void display()throws IOException
{ {
System.out.print("Enter any String : "); System.out.print("Enter any String : ");
String s=br.readLine(); String s=br.readLine();
String x= caseConvert(s,0); String x= caseConvert(s);
System.out.print("The new String = "+x); System.out.print("The new String = "+x);
} }

Instead of writing the case conversion code inside the recursive function, you can also send that character to
another function which is performing the case conversion. An example of this is given below: (ISC 2010)

String newstr=""; char caseConvert(char ch)

void recChange(String s, int i) {
{ if(Character.isUpperCase(ch))
if(i<s.length()) ch=Character.toLowerCase(ch);
{ else
char ch=s.charAt(i); ch=Character.toUpperCase(ch);
newstr=newstr+caseConvert(ch); return ch;
recChange(s,i+1); }
}
void display()throws IOException
else
{
System.out.print("The new word = "+newstr);
System.out.print("Enter any word : ");
}
String s=br.readLine();
recChange(s,0);
}
2. Printing the initials of a name

Recursive Method Corresponding Iterative Method

void initials(String s, int i) void initials(String s)

{ {
if(i<s.length()) int i=0;
{ while(i<s.length())
char ch=s.charAt(i); {
if(ch == ' ') char ch=s.charAt(i);
System.out.print(s.charAt(i+1)+"."); if(ch == ' ')
initials(s,i+1); System.out.print(s.charAt(i+1)+".");
} i++;
} }
}
void display()throws IOException void display()throws IOException
{ {
System.out.print("Enter any name : "); System.out.print("Enter any name : ");
String s=br.readLine(); String s=br.readLine();
s=" "+s; s=" "+s;
initials(s,0); initials(s);
} }

------------------------------------ © www.javaforschool.com -------------------------- Page 3 ---

JAVA FOR SCHOOL RECURSION
Making Java Fun To Learn Programs Related to Strings
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
In the above program, before sending the String to the recursive function, we have added a space before the
String and then sent it. This is in accordance with the logic that the initials of a name are the characters which are
just after a space.

3. Counting Number of UpperCase and LowerCase characters

Recursive Method Corresponding Iterative Method

int cap=0,sm=0; int cap=0,sm=0;

void countCase(String s, int i) void countCase(String s)
{ {
if(i<s.length()) int i=0;
{ while(i<s.length())
char ch=s.charAt(i); {
if(Character.isUpperCase(ch)) char ch=s.charAt(i);
cap++; if(Character.isUpperCase(ch))
if(Character.isLowerCase(ch)) cap++;
sm++; if(Character.isLowerCase(ch))
countCase(s,i+1); sm++;
} i++;
else }
{ System.out.println("No. of Capital letters = "+cap);
System.out.println("No. of Capital letters = "+cap); System.out.println("No. of Small letters = "+sm);
System.out.println("No. of Small letters = "+sm); }
}
}
void display()throws IOException void display()throws IOException
{ {
System.out.print("Enter any String : "); System.out.print("Enter any String : ");
String s=br.readLine(); String s=br.readLine();
countCase(s,0); countCase(s);
} }

The printing statements which are inside the else clause can also be written inside the display () function if we
don’t write them in the recursive function. The statements will be written after the statement countCase(s,0);
and in that case we won’t write any else part in the recursive function.

4. Counting frequency of a character in a String

Recursive Method Corresponding Iterative Method

int cou=0; int cou=0;

void count(String s, int i, char c) void count(String s, char c)
{ {
if(i<s.length()) int i=0;
{ while(i<s.length())
char ch=s.charAt(i); {
if(ch == c) char ch=s.charAt(i);
cou++; if(ch == c)
count(s,i+1,c); cou++;
} i++;
else }
System.out.println("Frequency of "+c+" = "+cou); System.out.println("Frequency of "+c+" = "+cou);
} }

void display()throws IOException void display()throws IOException

{ {
System.out.print("Enter any String : "); System.out.print("Enter any String : ");
String s=br.readLine(); String s=br.readLine();
System.out.print("Enter any character : "); System.out.print("Enter any character : ");
char c=(char)(System.in.read()); char c=(char)(System.in.read());
count(s,0,c); count(s,c);
} }

------------------------------------ © www.javaforschool.com -------------------------- Page 4 ---

JAVA FOR SCHOOL RECURSION
Making Java Fun To Learn Programs Related to Strings
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
5. Counting Number of spaces, words, vowels, digits and consonants in a sentence

Recursive Method Corresponding Iterative Method

int sp=0,word=0,vow=0,dig=0,con=0; int sp=0,word=0,vow=0,dig=0,con=0;

void count(String s, int i) void count(String s)
{ {
if(i<s.length()) int i=0;
{ while(i<s.length())
char ch=s.charAt(i); {
if(ch == ' ') char ch=s.charAt(i);
sp++; if(ch == ' ')
if(ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u'|| sp++;
ch=='A'||ch=='E'||ch=='I'||ch=='O'||ch=='U') if(ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u'||
vow++; ch=='A'||ch=='E'||ch=='I'||ch=='O'||ch=='U')
if(ch>='0' && ch<='9') vow++;
dig++; if(ch>='0' && ch<='9')
count(s,i+1); dig++;
} i++;
else }
{ word=sp+1;
word=sp+1; con=s.length()-(sp+vow+dig);
con=s.length()-(sp+vow+dig); System.out.println("No. of spaces = "+sp);
System.out.println("No. of spaces = "+sp); System.out.println("No. of words = "+word);
System.out.println("No. of words = "+word); System.out.println("No. of vowels = "+vow);
System.out.println("No. of vowels = "+vow); System.out.println("No. of consonants = "+con);
System.out.println("No. of consonants = "+con); System.out.println("No. of digits = "+dig);
System.out.println("No. of digits = "+dig); }
}
}
void display()throws IOException void display()throws IOException
{ {
System.out.print("Enter any sentence : "); System.out.print("Enter any sentence : ");
String s=br.readLine(); String s=br.readLine();
count(s,0); count(s);
} }

6. Printing the String after removing all the Vowels

Recursive Method Corresponding Iterative Method

void remVow(String s, int i) void remVow(String s)

{ {
if(i<s.length()) int i=0;
{ while(i<s.length())
char ch=s.charAt(i); {
if(ch!='a' && ch!='e' && ch!='i' && ch!='o' && ch!='u' char ch=s.charAt(i);
&& ch!='A' && ch!='E' && ch!='I' && ch!='O' if(ch!='a' && ch!='e' && ch!='i' && ch!='o' && ch!='u'
&&ch!='U') && ch!='A' && ch!='E' && ch!='I' && ch!='O'
System.out.print(ch); &&ch!='U')
remVow(s,i+1); System.out.print(ch);
} i++;
} }
}

void display()throws IOException void display()throws IOException

{ {
System.out.print("Enter any String : "); System.out.print("Enter any String : ");
String s=br.readLine(); String s=br.readLine();
System.out.print("The String after removing vowels : System.out.print("The String after removing vowels :
"); ");
remVow(s,0); remVow(s);
} }

------------------------------------ © www.javaforschool.com -------------------------- Page 5 ---

JAVA FOR SCHOOL RECURSION
Making Java Fun To Learn Programs Related to Strings
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
7. Printing Pattern

If String is "JAVAFORSCHOOL" then: J

JA
JAV
JAVA
JAVAF
JAVAFO
JAVAFOR
JAVAFORS
JAVAFORSC
JAVAFORSCH
JAVAFORSCHO
JAVAFORSCHOO
JAVAFORSCHOOL

Recursive Method 1 Corresponding Iterative Method

void pattern(String s, int i) void pattern(String s)

{ {
if(i<s.length()) int i=0;
{ while(i<s.length())
for(int j=0;j<=i;j++) {
{ for(int j=0;j<=i;j++)
char ch=s.charAt(j); {
System.out.print(ch); char ch=s.charAt(j);
} System.out.print(ch);
System.out.println(); }
pattern(s,i+1); System.out.println();
} i++;
} }
}

void display()throws IOException void display()throws IOException

{ {
System.out.print("Enter any String : "); System.out.print("Enter any String : ");
String s=br.readLine(); String s=br.readLine();
System.out.println("Output : "); System.out.println("Output : ");
pattern(s,0); pattern(s);
} }

Recursive Method 2 Corresponding Iterative Method

void pattern(String s, int i) void pattern(String s)

{ {
if(i<s.length()) int i=0;
{ while(i<s.length())
System.out.print(s.substring(0,i+1)); {
System.out.println(); System.out.print(s.substring(0,i+1));
pattern(s,i+1); System.out.println();
} i++;
} }
}

void display()throws IOException

void display()throws IOException {
{ System.out.print("Enter any String : ");
System.out.print("Enter any String : "); String s=br.readLine();
String s=br.readLine(); System.out.println("Output : ");
System.out.println("Output : "); pattern(s);
pattern(s,0); }
}

------------------------------------ © www.javaforschool.com -------------------------- Page 6 ---

JAVA FOR SCHOOL RECURSION
Making Java Fun To Learn Programs Related to Strings
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
8. Printing Pattern

If String is "JAVAFORSCHOOL" then: JAVAFORSCHOOL

JAVAFORSCHOO
JAVAFORSCHO
JAVAFORSCH
JAVAFORSC
JAVAFORS
JAVAFOR
JAVAFO
JAVAF
JAVA
JAV
JA
J

Recursive Method 1 Corresponding Iterative Method

void pattern(String s, int i) void pattern(String s)

{ {
if(i>=0) int i=s.length()-1;
{ while(i>=0)
for(int j=0;j<=i;j++) {
{ for(int j=0;j<=i;j++)
char ch=s.charAt(j); {
System.out.print(ch); char ch=s.charAt(j);
} System.out.print(ch);
System.out.println(); }
pattern(s,i-1); System.out.println();
} i=i-1;
} }
}

void display()throws IOException void display()throws IOException

{ {
System.out.print("Enter any String : "); System.out.print("Enter any String : ");
String s=br.readLine(); String s=br.readLine();
int len=s.length(); System.out.println("Output : ");
System.out.println("Output : "); pattern(s);
pattern(s,len-1); }
}

Recursive Method 2 Corresponding Iterative Method

void pattern(String s, int i) void pattern(String s)

{ {
if(i>=0) int i=s.length()-1;
{ while(i>=0)
System.out.print(s.substring(0,i+1)); {
System.out.println(); System.out.print(s.substring(0,i+1));
pattern(s,i-1); System.out.println();
} i=i-1;
} }
}

void display()throws IOException void display()throws IOException

{ {
System.out.print("Enter any String : "); System.out.print("Enter any String : ");
String s=br.readLine(); String s=br.readLine();
int len=s.length(); System.out.println("Output : ");
System.out.println("Output : "); pattern(s);
pattern(s,len-1); }
}

------------------------------------ © www.javaforschool.com -------------------------- Page 7 ---

JAVA FOR SCHOOL RECURSION
Making Java Fun To Learn Programs Related to Strings
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
9. Printing the digits of a number in words

Recursive Method Corresponding Iterative Method

void digit(String n, int i) void digit(String n)
{ {
if(i<n.length()) int i=0;
{ while(i<n.length())
char ch=n.charAt(i); {
printWord(ch); char ch=n.charAt(i);
digit(n,i+1); printWord(ch);
}} i++;
}}
void printWord(char ch) void printWord(char ch)
{ {
switch(ch) switch(ch)
{ {
case '0': System.out.print("Zero "); break; case '0': System.out.print("Zero "); break;
case '1': System.out.print("One "); break; case '1': System.out.print("One "); break;
case '2': System.out.print("Two "); break; case '2': System.out.print("Two "); break;
case '3': System.out.print("Three "); break; case '3': System.out.print("Three "); break;
case '4': System.out.print("Four "); break; case '4': System.out.print("Four "); break;
case '5': System.out.print("Five "); break; case '5': System.out.print("Five "); break;
case '6': System.out.print("Six "); break; case '6': System.out.print("Six "); break;
case '7': System.out.print("Seven "); break; case '7': System.out.print("Seven "); break;
case '8': System.out.print("Eight "); break; case '8': System.out.print("Eight "); break;
case '9': System.out.print("Nine "); break; case '9': System.out.print("Nine "); break;
} }
} }
void display()throws IOException void display()throws IOException
{ {
System.out.print("Enter any number : "); System.out.print("Enter any number : ");
String n=br.readLine(); String n=br.readLine();
System.out.print("Output : "); System.out.print("Output : ");
digit(n,0); digit(n);
} }

In the above program, we have asked the user to enter a number, but have stored it as a String and not an
Integer.

10. Arranging a String in Alphabetical order

Recursive Method Corresponding Iterative Method

String newstr=""; String newstr="";
void alpha(String s,int k) void alpha(String s)
{ {
if(k<=90) int k=65;
{ while(k<=90)
for(int i=0;i<s.length();i++) {
{ for(int i=0;i<s.length();i++)
char ch=s.charAt(i); {
if(ch==(char)k||ch==(char)(k+32)) char ch=s.charAt(i);
{ if(ch==(char)k||ch==(char)(k+32))
newstr=newstr+ch; {
} newstr=newstr+ch;
} }
alpha(s,k+1); }
} k++;
else }
System.out.print("Output : "+newstr); System.out.print("Output : "+newstr);
} }
void display()throws IOException void display()throws IOException
{ {
System.out.print("Enter any String : "); System.out.print("Enter any String : ");
String s=br.readLine(); String s=br.readLine();
digit(s,65); digit(s);
} }

------------------------------------ © www.javaforschool.com -------------------------- Page 8 ---

JAVA FOR SCHOOL RECURSION
Making Java Fun To Learn Programs Related to Strings
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
In the above recursive method alpha(), we are passing another variable 'k' which is for comparing the ASCII
values of each characters. The ASCII value of 'A' is 65, hence the starting value of variable 'k' is sent as 65 and
the value of variable 'k' goes on till 90 which is the ASCII value of 'Z'.

Inside the recursive method alpha() we have written a for-loop which will run from the starting of the String till
the end for every English alphabets i.e. this for loop will execute 26 times.

11. Encoding every character by 2 positions

Recursive Method Corresponding Iterative Method

void encode(String s, int i) void encode(String s)

{ {
if(i<s.length()) int i=0;
{ while(i<s.length())
char ch=s.charAt(i); {
if((ch>='a'&&ch<='x') || (ch>='A'&&ch<='X')) char ch=s.charAt(i);
ch=(char)(ch+2); if((ch>='a'&&ch<='x') || (ch>='A'&&ch<='X'))
if(ch=='y'||ch=='Y'||ch=='z'||ch=='Z') ch=(char)(ch+2);
ch=(char)(ch-24); if(ch=='y'||ch=='Y'||ch=='z'||ch=='Z')
System.out.print(ch); ch=(char)(ch-24);
encode(s,i+1); System.out.print(ch);
} i++;
} }
}
void display()throws IOException void display()throws IOException
{ {
System.out.print("Enter any word : "); System.out.print("Enter any word : ");
String s=br.readLine(); String s=br.readLine();
System.out.print("The Encoded word = "); System.out.print("The Encoded word = ");
encode(s,0); encode(s,0);
} }

12. Finding the position of the First vowel

Recursive Method Iterative Method

int vowFirst(String s, int i) int vowFirst(String s)

{ {
if(i<s.length()) int i=0,p=-1;
{ while(i<s.length())
char ch=s.charAt(i); {
if(ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u'|| char ch=s.charAt(i);
ch=='A'||ch=='E'||ch=='I'||ch=='O'||ch=='U') if(ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u'||
{ ch=='A'||ch=='E'||ch=='I'||ch=='O'||ch=='U')
return i; {
} p=i;
return (vowFirst(s,i+1)); break;
} }
return -1; i++;
} }
return p;
}
void display()throws IOException void display()throws IOException
{ {
System.out.print("Enter any String : "); System.out.print("Enter any String : ");
String s=br.readLine(); String s=br.readLine();
int pos=vowFirst(s,0); int pos=vowFirst(s);
if(pos!=-1) if(pos!=-1)
System.out.print("Position of first Vowel = "+pos); System.out.print("Position of first Vowel = "+pos);
else else
System.out.println("No Vowel Found "); System.out.println("No Vowel Found ");
} }

In the above recursive method vowFirst(), we are returning a (-1) when we are not getting any vowel. If we get
a vowel then we are returning that position.

------------------------------------ © www.javaforschool.com -------------------------- Page 9 ---

JAVA FOR SCHOOL RECURSION
Making Java Fun To Learn Programs Related to Strings
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Writing a return statement inside the if-block when we get a vowel, allows us to stop the execution of the
function if we get a vowel. return keyword allows us to stop the execution of a function and transfers the control
back to the calling function. In the iterative method, we are using the keyword break to stop the while loop when
we get the first vowel. In the display() method, we are printing the position of the first vowel, if the return value is
not -1, else we are printing an error message.

13. Finding the position of the Last vowel

Recursive Method Iterative Method

int p=-1; int vowFirst(String s)

int vowLast(String s, int i) {
{ int i=0,p=-1;
if(i<s.length()) while(i<s.length())
{ {
char ch=s.charAt(i); char ch=s.charAt(i);
if(ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u'|| if(ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u'||
ch=='A'||ch=='E'||ch=='I'||ch=='O'||ch=='U') ch=='A'||ch=='E'||ch=='I'||ch=='O'||ch=='U')
p=i; p=i;
return (vowLast(s,i+1)); i++;
} }
return p; return p;
} }
void display()throws IOException void display()throws IOException
{ {
System.out.print("Enter any String : "); System.out.print("Enter any String : ");
String s=br.readLine(); String s=br.readLine();
int pos=vowLast(s,0); int pos=vowFirst(s);
if(pos!=-1) if(pos!=-1)
System.out.print("Position of last Vowel = "+pos); System.out.print("Position of last Vowel = "+pos);
else else
System.out.println("No Vowel Found "); System.out.println("No Vowel Found ");
} }

Removing the return keyword from within the if-block allows the recursive function to find the position of the last
vowel. Similarly, Removing the break keyword from within the if-block allows the Iterative function to find the
position of the last vowel.

14. Printing and Counting the Double letter sequence present in a sentence

Recursive Method Corresponding Iterative Method

int count=0; int count=0,i=0;
void doubleLetter(String s, int i) void doubleLetter(String s)
{ {
if(i<s.length()-1) while(i<s.length()-1)
{ {
char ch1=s.charAt(i); char ch1=s.charAt(i);
char ch2=s.charAt(i+1); char ch2=s.charAt(i+1);
if(ch1==ch2) if(ch1==ch2)
{ {
System.out.println(ch1+","+ch2); System.out.println(ch1+","+ch2);
count++; count++;
} }
doubleLetter(s,i+1); i++;
} }
} }
void display()throws IOException void display()throws IOException
{ {
System.out.print("Enter any sentence : "); System.out.print("Enter any sentence : ");
String s=br.readLine(); String s=br.readLine();
s=s.toUpperCase(); s=s.toUpperCase();
System.out.println("The Double letter pairs are : "); System.out.println("The Double letter pairs are : ");
doubleLetter(s,0); doubleLetter(s);
System.out.println("No. of pairs = "+count); System.out.println("No. of pairs = "+count);
} }

------------------------------------ © www.javaforschool.com -------------------------- Page 10 ---

JAVA FOR SCHOOL RECURSION
Making Java Fun To Learn Programs Related to Strings
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
15. Printing and Counting the Consecutive Character sequence present in a
sentence

Recursive Method Corresponding Iterative Method

int count=0; int count=0,i=0;
void consecLetter(String s, int i) void consecLetter(String s, int i)
{ {
if(i<s.length()-1) while(i<s.length()-1)
{ {
char ch1=s.charAt(i); char ch1=s.charAt(i);
char ch2=s.charAt(i+1); char ch2=s.charAt(i+1);
if((int)ch2-(int)ch1==1) if((int)ch2-(int)ch1==1)
{ {
System.out.println(ch1+","+ch2); System.out.println(ch1+","+ch2);
count++; count++;
} }
consecLetter(s,i+1); i++;
} }
} }
void display()throws IOException void display()throws IOException
{ {
System.out.print("Enter any sentence : "); System.out.print("Enter any sentence : ");
String s=br.readLine(); String s=br.readLine();
s=s.toUpperCase(); s=s.toUpperCase();
System.out.println("Consecutive letter pairs are : "); System.out.println("Consecutive letter pairs are : ");
consecLetter(s,0); consecLetter(s);
System.out.println("No. of pairs = "+count); System.out.println("No. of pairs = "+count);
} }

If the characters are consecutive as in the English Alphabets, then the difference in the ASCII values of the 2nd
character and the 1st character will be one. This is what we are checking in the recursive function.

16. Forming a new word by taking first character of every word in a sentence

Recursive Method Corresponding Iterative Method

String newstr=""; String newstr="";
String newWord(String s, int i) String newWord(String s)
{ {
if(i<s.length()-1) int i=0;
{ while(i<s.length()-1)
char ch=s.charAt(i); {
if(ch == ' ') char ch=s.charAt(i);
newstr=newstr+s.charAt(i+1); if(ch == ' ')
newWord(s,i+1); newstr=newstr+s.charAt(i+1);
} i++;
return newstr; }
} return newstr;
}

void display()throws IOException void display()throws IOException

{ {
System.out.print("Enter any sentence : "); System.out.print("Enter any sentence : ");
String s=br.readLine(); String s=br.readLine();
s=" "+s; s=" "+s;
String x= newWord(s,0); String x= newWord(s);
System.out.println("The New Word : "+x); System.out.println("The New Word : "+x);
} }

As soon as we are encountering a space, we are adding the character just next to it to the variable 'newstr'.

Note: Before sending the String to the recursive function, we have added a space before the String.

------------------------------------ © www.javaforschool.com -------------------------- Page 11 ---

JAVA FOR SCHOOL RECURSION
Making Java Fun To Learn Programs Related to Strings
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
17. Finding the Piglatin of a word
In this program you first need to find the position of the first vowel. You can do this by either the recursive
method or the iterative method we discussed of finding the first vowel or you can even find the position of the first
vowel inside the display() method.
In this example we have used the recursive function for finding the first vowel.

String piggy=""; {
int vowFirst(String s, int i) char ch=s.charAt(i);
{ piggy=piggy+ch;
if(i<s.length()) piglatin(s,i+1,q);
{ }
char ch=s.charAt(i); }
if(ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u'||
ch=='A'||ch=='E'||ch=='I'||ch=='O'||ch=='U') void display()throws IOException
{ {
return i; System.out.print("Enter any word : ");
} String s=br.readLine();
return (vowFirst(s,i+1)); int len=s.length();
} int p=vowFirst(s,0);
return 0; piglatin(s,p,len);
} piglatin(s,0,p);
piggy=piggy+"ay";
void piglatin(String s, int i, int q) System.out.println("The Piglatin of the word =
{ "+piggy);
if(i<q) }

18. Finding the Frequency of each characters present in a word

import java.io.*; }
class Recursion void display()throws IOException
{ {
static BufferedReader br=new BufferedReader(new System.out.print("Enter any string : ");
InputStreamReader(System.in)); String s=br.readLine();
int cap[]=new int[26]; System.out.println("Character\t\tFrequency");
int sm[]=new int[26]; freqChar(s,0);
Recursion() for(int i=0;i<26;i++)
{ {
for(int i=0;i<26;i++) if(cap[i]!=0)
{ System.out.println((char)(i+65)+"\t\t\t"+cap[i]);
cap[i]=0; }
sm[i]=0; for(int i=0;i<26;i++)
} {
} if(sm[i]!=0)
void freqChar(String s, int i) System.out.println((char)(i+97)+"\t\t\t"+sm[i]);
{ }
if(i<s.length()) }
{
char ch=s.charAt(i); public static void main()throws IOException
if(ch>='A'&&ch<='Z') {
cap[ch-65]++; Recursion ob=new Recursion();
if(ch>='a'&&ch<='z') ob.display();
sm[ch-97]++; }
freqChar(s,i+1); }
}

In the above example, the array cap[] is storing the frequency of the capital letters present in the string, and the
array sm[] is storing the frequency of the small letters present in the string. In the display() method, we are
first displaying the frequencies of the capital letters and then the small letters.

------------------------------------ © www.javaforschool.com -------------------------- Page 12 ---

JAVA FOR SCHOOL RECURSION
Making Java Fun To Learn Programs Related to Strings
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Extracting words of a String and performing any given operation
Recursive Method Iterative Method

String w=""; String w="";

void word(String s, int i) void word(String)
{ {
if(i<s.length()) int i=0;
{ while(i<s.length())
char ch=s.charAt(i); {
if(ch!=' ') char ch=s.charAt(i);
{ if(ch!=' ')
w=w+ch; {
} w=w+ch;
else }
{ else
{
Write the operation you want to perform with
the word stored in 'w' over here. Write the operation you want to perform with
w=""; the word stored in 'w' over here.
} w="";
word(s,i+1); }
} i++;
} }}

In the code given on the left , we are extracting the characters from the beginning of the String passed as
parameter and checking whether that character stored in 'ch' is a space or not. If the character is not a space,
then we add it to the String variable 'w'. When the character is a space, then we have got a word, and hence you
write what you want to do with the word stored in 'w' in the else-block.
Important Note: While using the above code, after entering the String from the user, you need to add a space at
its end before passing it on to the recursive method.

Some Programs using the above technique

1. Printing each word of a sentence along with their lengths

Recursive Method Corresponding Iterative Method

String w=""; String w="";
int len=0; int len=0,i=0;
void word(String s, int i) void word(String s)
{ {
if(i<s.length()) while(i<s.length())
{ {
char ch=s.charAt(i); char ch=s.charAt(i);
if(ch!=' ') if(ch!=' ')
w=w+ch; w=w+ch;
else else
{ {
len=w.length(); len=w.length();
System.out.println(w+"\t\t"+len); System.out.println(w+"\t\t"+len);
w=""; w="";
} }
word(s,i+1); i++;
} }
} }
void display()throws IOException void display()throws IOException
{ {
System.out.print("Enter any sentence : "); System.out.print("Enter any sentence : ");
String s=br.readLine(); String s=br.readLine();
s=s+" "; s=s+" ";
System.out.println("Words\t\tLength"); System.out.println("Words\t\tLength");
word(s,0); word(s);
} }

Note: We have added a space after the inputted sentence in the display () method.

----------------------------------- © www.javaforschool.com ----------------------------- Page 13 ---

JAVA FOR SCHOOL RECURSION
Making Java Fun To Learn Programs Related to Strings
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
2. Printing the reverse of each word in a sentence

Recursive Method Corresponding Iterative Method

String w=""; String w="";
void word(String s, int i) void word(String s)
{ {
if(i<s.length()) int i=0;
{ while(i<s.length())
char ch=s.charAt(i); {
if(ch!=' ') char ch=s.charAt(i);
w=ch+w; if(ch!=' ')
else w=ch+w;
{ else
System.out.println(w); {
w=""; System.out.println(w);
} w="";
word(s,i+1); }
} i++;
} }
}
void display()throws IOException void display()throws IOException
{ {
System.out.print("Enter any sentence : "); System.out.print("Enter any sentence : ");
String s=br.readLine(); String s=br.readLine();
s=s+" "; s=s+" ";
word(s,0); word(s);
} }

The change in the line of adding the character i.e. w=ch+w; reverses the word by adding the character before
rather than after.

3. Printing the words which begin with a vowel

Recursive Method Corresponding Iterative Method

String w=""; String w=""; int i=0;
void word(String s, int i) void word(String s)
{ {
if(i<s.length()) while(i<s.length())
{ {
char ch=s.charAt(i); char ch=s.charAt(i);
if(ch!=' ') if(ch!=' ')
w=w+ch; w=w+ch;
else else
{ {
char c=w.charAt(0); char c=w.charAt(0);
if(c=='a'||c=='e'||c=='i'||c=='o'||c=='u'||c=='A'|| if(c=='a'||c=='e'||c=='i'||c=='o'||c=='u'||c=='A'||
c=='E'||c=='I'||c=='O'||c=='U') c=='E'||c=='I'||c=='O'||c=='U')
{ {
System.out.println(w); System.out.println(w);
} }
w=""; w="";
} }
word(s,i+1); i++;
} }
} }

void display()throws IOException void display()throws IOException

{ {
System.out.print("Enter any sentence : "); System.out.print("Enter any sentence : ");
String s=br.readLine(); String s=br.readLine();
s=s+" "; s=s+" ";
System.out.print("Words beginning with vowel are : System.out.print("Words beginning with vowel are :
"); ");
word(s,0); word(s);
} }

----------------------------------- © www.javaforschool.com ----------------------------- Page 14 ---

JAVA FOR SCHOOL RECURSION
Making Java Fun To Learn Programs Related to Strings
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
4. Searching for a word in a sentence

Recursive Method Corresponding Iterative Method

String w=""; String w=""; int i=0, flag=0;
int word(String s, int i, String search) int word(String s, String search)
{ {
if(i<s.length()) while(i<s.length())
{ {
char ch=s.charAt(i); char ch=s.charAt(i);
if(ch!=' ') if(ch!=' ')
w=w+ch; w=w+ch;
else else
{ {
if(w.equalsIgnoreCase(search)) if(w.equalsIgnoreCase(search))
return 1; flag=1;
w=""; w="";
} }
return (word(s,i+1,search)); i++;
} }
return 0; return flag;
} }
void display()throws IOException void display()throws IOException
{ {
System.out.print("Enter any sentence : "); System.out.print("Enter any sentence : ");
String s=br.readLine(); String s=br.readLine();
s=s+" "; s=s+" ";
System.out.print("Enter the word to search : "); System.out.print("Enter the word to search : ");
String search=br.readLine(); String search=br.readLine();
int res=word(s,0,search); int res=word(s, search);
if(res==1) if(res==1)
System.out.println("Word Found"); System.out.println("Word Found");
else else
System.out.print("Word is not present"); System.out.print("Word is not present");
} }

5. Removing a particular word from a sentence

Recursive Method Corresponding Iterative Method

String w="",newstr=""; String w="",newstr=""; int i=0;
void word(String s, int i, String rem) void word(String s, String rem)
{ {
if(i<s.length()) while(i<s.length())
{ {
char ch=s.charAt(i); char ch=s.charAt(i);
if(ch!=' ') if(ch!=' ')
w=w+ch; w=w+ch;
else else
{ {
if(w.equalsIgnoreCase(rem)==false) if(w.equalsIgnoreCase(rem)==false)
newstr=newstr+w+" "; newstr=newstr+w+" ";
w=""; w="";
} }
word(s,i+1,rem); i++;
} }
else System.out.println("Output : "+newstr);
System.out.println("Output : "+newstr); }
}
void display()throws IOException void display()throws IOException
{ {
System.out.print("Enter any sentence : "); System.out.print("Enter any sentence : ");
String s=br.readLine(); String s=br.readLine();
s=s+" "; s=s+" ";
System.out.print("Enter the word to remove : "); System.out.print("Enter the word to remove : ");
String rem=br.readLine(); String rem=br.readLine();
word(s,0,rem); word(s,rem);
} }

----------------------------------- © www.javaforschool.com ----------------------------- Page 15 ---

JAVA FOR SCHOOL RECURSION
Making Java Fun To Learn Programs Related to Strings
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Note: In both of the codes above for searching for a word or removing a word, we need to send the word we want
to search or remove also into the recursive function as a parameter.

In the code for removing a word, the recursive function is extracting one word at a time and adding it to the new
string whenever the word is not equal to the word we want to remove.

6. Replacing a particular word with another word

Recursive Method Corresponding Iterative Method

import java.io.*; import java.io.*;
class Recursion class Recursion
{ {
static BufferedReader br=new BufferedReader(new static BufferedReader br=new BufferedReader(new
InputStreamReader(System.in)); InputStreamReader(System.in));

String w="",newstr=""; String w="",newstr=""; int i=0;

void word(String s, int i, String rep, String n) void word(String s, String rep, String n)
{ {
if(i<s.length()) while(i<s.length())
{ {
char ch=s.charAt(i); char ch=s.charAt(i);
if(ch!=' ') if(ch!=' ')
w=w+ch; w=w+ch;
else else
{ {
if(w.equalsIgnoreCase(rep)) if(w.equalsIgnoreCase(rep))
{ {
w=n; w=n;
} }
newstr=newstr+w+" "; newstr=newstr+w+" ";
w=""; w="";
} }
word(s,i+1,rep,n); i++;
} }
else System.out.println("Output : "+newstr);
System.out.println("Output : "+newstr); }
}
void display()throws IOException
void display()throws IOException {
{ System.out.print("Enter any sentence : ");
System.out.print("Enter any sentence : "); String s=br.readLine();
String s=br.readLine(); s=s+" ";
s=s+" "; System.out.print("Enter the word to replace : ");
System.out.print("Enter the word to replace : "); String rep=br.readLine();
String rep=br.readLine(); System.out.print("Enter the new word : ");
System.out.print("Enter the new word : "); String n=br.readLine();
String n=br.readLine(); word(s,rep,n);
word(s,0,rep,n); }
}
public static void main()throws IOException
public static void main()throws IOException {
{ Recursion ob=new Recursion();
Recursion ob=new Recursion(); ob.display();
ob.display(); }
} }
}

Note: We need to send the word we want to replace and also the new word into the recursive function as a
parameter.

The recursive function is extracting one word at a time and checking whether that word is the same as the word
we want to replace or not. If yes, then the word is replaced with the new word and added to the new word.

----------------------------------- © www.javaforschool.com ----------------------------- Page 16 ---

JAVA FOR SCHOOL RECURSION
Making Java Fun To Learn Programs Related to Strings
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
7. Printing the Piglatin of each word of a sentence

Recursive Method Corresponding Iterative Method

import java.io.*; import java.io.*;
class Recursion class Recursion
{ {
static BufferedReader br=new BufferedReader(new static BufferedReader br=new BufferedReader(new
InputStreamReader(System.in)); InputStreamReader(System.in));
String w=""; String w="";
int len=0; int len=0, i=0;
void word(String s, int i) void word(String s)
{ {
if(i<s.length()) while(i<s.length())
{ {
char ch=s.charAt(i); char ch=s.charAt(i);
if(ch!=' ') if(ch!=' ')
w=w+ch; w=w+ch;
else else
{ {
piglatin(w); piglatin(w);
w=""; w="";
} }
word(s,i+1); i++;
} }
} }

void piglatin(String s) void piglatin(String s)

{ {
int p=0; int p=0;
for(int k=0;k<s.length();k++) for(int k=0;k<s.length();k++)
{ {
char ch=s.charAt(k); char ch=s.charAt(k);
if(ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u'|| if(ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u'||
ch=='A'||ch=='E'||ch=='I'||ch=='O'||ch=='U') ch=='A'||ch=='E'||ch=='I'||ch=='O'||ch=='U')
{ {
p=k; p=k;
break; break;
} }
} }
String a=s.substring(p); String a=s.substring(p);
String b=s.substring(0,p); String b=s.substring(0,p);
String piggy=a+b+"ay"; String piggy=a+b+"ay";
System.out.print(piggy+" "); System.out.print(piggy+" ");
} }
void display()throws IOException void display()throws IOException
{ {
System.out.print("Enter any sentence : "); System.out.print("Enter any sentence : ");
String s=br.readLine(); String s=br.readLine();
s=s+" "; s=s+" ";
System.out.print("Output: "); System.out.print("Output: ");
word(s,0); word(s);
} }
public static void main()throws IOException public static void main()throws IOException
{ {
Recursion ob=new Recursion(); Recursion ob=new Recursion();
ob.display(); ob.display();
} }
} }

The recursive function word() is extracting one word at a time and sending it to the function piglatin(), which is
first finding the position of the first vowel of each word and then doing the needful for converting the word into a
piglatin.
Note: Here the function piglatin() is non-recursive i.e. iterative. Also, we have added a space after the inputted
sentence in the display() method.

----------------------------------- © www.javaforschool.com ----------------------------- Page 17 ---