last string should come first. Should use RECURSION

String str = "Blog spots welcomes you friends";
    String temp = "";
    String finalString = "";
        for(int i =str.length()-1;i>=0;i--){
            temp +=i!=0?str.charAt(i):str.charAt(i)+" ";
            if(str.charAt(i) == ' '||i==0){
                for(int j=temp.length()-1;j>=0;j--){
                    finalString += temp.charAt(j);
                }
                temp = "";
            }
        }
            System.out.println(finalString);
    }
}

Java Find the Next Greatest Element

final class DataSet {

    private final int x;
    private final int nextX;

    public DataSet(int x, int nextX) {
        this.x  = x;
        this.nextX = nextX;
    }

    public int getX() {
        return x;
    }

    public int getNextX() {
        return nextX;
    }

 
    public String toString() {
        return "x: " + x + " nextX: " + nextX;
    }

 
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + nextX;
        result = prime * result + x;
        return result;
    }

 
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        DataSet other = (DataSet) obj;
        if (nextX != other.nextX)
            return false;
        if (x != other.x)
            return false;
        return true;
    }
}

public final class NextGreatestElement {

    private NextGreatestElement() {  
   
   public static List<DataSet> getNextGreatestElement(int[] a) {

        final List<DataSet> dataSetList = new ArrayList<DataSet>();
        final Stack<Integer> stack = new Stack<Integer>();

        for (int i = 0; i < a.length; i++) {

            while (!stack.isEmpty() && stack.peek() < a[i]) {
                dataSetList.add(new DataSet(stack.pop(), a[i]));
            }

            stack.push(a[i]);
        }

        while (!stack.isEmpty()) {
            dataSetList.add(new DataSet(stack.pop(), -1));
        }


        return dataSetList;
    }
}

public class NextGreatestElementTest {

 
    public void test1() {
        int[] a1 = {2, 3, 4, 5};
        List<DataSet> ds1 = new ArrayList<DataSet>();
        ds1.add(new DataSet(2, 3));
        ds1.add(new DataSet(3, 4));
        ds1.add(new DataSet(4, 5));
        ds1.add(new DataSet(5, -1));
        assertEquals(ds1,  NextGreatestElement.getNextGreatestElement(a1));
    }
 public void test2() {
        int[] a2 = {3, 2, 1};
        List<DataSet> ds2 = new ArrayList<DataSet>();
        ds2.add(new DataSet(1, -1));
        ds2.add(new DataSet(2, -1));
        ds2.add(new DataSet(3, -1));
        assertEquals(ds2, NextGreatestElement.getNextGreatestElement(a2));
    }
}

Print all Subsequences of String which Start with Vowel and End with Consonant

import java.util.HashSet;

public class Example {

   
    static HashSet<String> st = new HashSet<>();
    static void subsequence(String str)
    {
       
        for (int i = 0; i < str.length(); i++) {
       
           
            if (isVowel(str.charAt(i))) {
       
             
                for (int j = (str.length() - 1); j >= i; j--) {
                   
                   
                    if (isConsonant(str.charAt((j)))) {
                   
                    String str_sub = str.substring(i, j + 1);
                        st.add(str_sub);
  for (int k = 1; k < str_sub.length() - 1; k++) {
                            StringBuffer sb = new StringBuffer(str_sub);
                            sb.deleteCharAt(k);
                            subsequence(sb.toString());
                        }
                    }
                }
            }
        }
    }

   
    static boolean isVowel(char c)
    {
        return (c == 'a' || c == 'e' || c == 'i' || c == 'o'
                                              || c == 'u');
    }

    static boolean isConsonant(char c)
    {
        return !(c == 'a' || c == 'e' || c == 'i' || c == 'o'
                                              || c == 'u');
    }

    public static void main(String[] args)
    {
        String s = "abcdefg";
        subsequence(s);
        System.out.println(st);
    }
}

Given a string, reverse only vowels in it; leaving rest of the string as it is

public class Vowel {  

      

      public static void main(String[] str) {  

          

        String originalstring = "MODERNPATHSHALA";  

        String reversedString =  reverseVowels(originalstring);  

        System.out.println(originalstring + " after vowels reversed = " + reversedString);  

  

    }  

      

      

    public static String reverseVowels(String originalstring) {  

        if (originalstring == null || originalstring.length() < 2)  

            return originalstring;  

  

        int len = originalstring.length();  

        int i = 0;  

        int j = len - 1;  

        char[] array = originalstring.toCharArray();  

        while (i < j) {  

            while (i < j && !isVowel(array[i]))  

                i++;  

            while (j > i && !isVowel(array[j]))  

                j--;  

            swap(array, i, j);  

            i++;  

            j--;  

        }  

        return String.valueOf(array);  

    }  

  

    

    public static boolean isVowel(char c) {  

        switch (c) {  

        case 'a':  

        case 'e':  

        case 'i':  

        case 'o':  

        case 'u':  

        case 'A':  

        case 'E':  

        case 'I':  

        case 'O':  

        case 'U':  

            return true;  

        default:  

            return false;  

        }  

    }  

  

    public static void swap(char[] arr, int i, int j) {  

        char tmp = arr[i];  

        arr[i] = arr[j];  

        arr[j] = tmp;  

    }  

}  

Reverse And Add A Number Until You Get A Palindrome number

import java.util.Scanner;

public class example
{
 
   
    static int reverseNumber(int number)
    {
        int reverse = 0;
       
        int rem = 0;
       
        while (number != 0)
        {
            rem = number % 10;
           
            reverse = (reverse*10) + rem;
           
            number = number/10;
        }
       
        return reverse;
    }
   
 
   
    static boolean checkPalindrome(int number)
    {
        int reverse = reverseNumber(number);
       
        if(reverse == number)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
   
 
   
    static void reverseAndAdd(int number)
    {
        if(checkPalindrome(number))
        {
            System.out.println("Given Number is already a palindrome");
        }
        else
        {
            while (!checkPalindrome(number))
            {
                int reverse = reverseNumber(number);
               
                int sum = number + reverse;
               
                System.out.println(number+" + "+reverse+" = "+sum);
               
                number = sum;
            }
        }
    }
   
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
       
        System.out.println("Enter Number : ");
       
        int inputNumber = sc.nextInt();
       
        reverseAndAdd(inputNumber);
    }
}

distance between points

public class Strecke {
    Punkt p1, p2;
    Strecke (Punkt punkt1, Punkt punkt2) {
        this.p1 = punkt1;
        this.p2 = punkt2;
    }
    public Punkt mittelPunkt() {
        return new Punkt ((p1.getX()+p2.getX())/2, (p1.getY()+p2.getY())/2);
    }
    public double abstand() {
        return Math.sqrt(
            (p1.getX() - p2.getX()) *  (p1.getX() - p2.getX()) +
            (p1.getY() - p2.getY()) *  (p1.getY() - p2.getY())
        );
    }
    static public void main (String args[]) {
        Strecke s = new Strecke (new Punkt(2.0, 2.0), new Punkt(5.0, 6.0));
        Punkt mp = s.mittelPunkt();
        System.out.println ("Midpoint = (" + mp.getX() + "," + mp.getY() + ")");
        double as = s.abstand();
        System.out.println ("Length   = " + as);
    }
}

sudoku

public class Sudok {

int[][] sudoku;
String data;
 public SudokuSolver()
 {
     getPuzzle();
     solvePuzzle(0,0);
 }

 private void getPuzzle()
 {
     try
     {
         Scanner in = new Scanner(new File("C:/Users/Ben/workspace/Sudoku      Solver/src/puzzle1.txt"));
         sudoku = new int[9][9];
         for(int y = 0; y<9;y++)
         {
             for(int x = 0; x<9; x++)
             {
                 data = in.next();
                 if(data.equals("."))
                     sudoku[x][y]=0;
                 else
                     sudoku[x][y] = Integer.parseInt(data);    
             }
         }
         in.close();
     }
     catch(Exception e)
     {

     }
     for(int y = 0; y<9; y++)
     {

         for(int x = 0; x<9; x++)
         {
             System.out.print(sudoku[x][y]);
             if(x ==2 || x ==5)
                 System.out.print("  ");
             if(x==8)
             {
                 System.out.print("\n");
             }

         }
         if(y == 2|| y == 5)
         {
             System.out.println(" ");
         }
     }

 }

 private boolean isValid(int x, int y, int num)
 {
     int xSection = x/3;
     int ySection = y/3;

     for ( int row = 0; row < sudoku.length; row++ )
     {
         if(sudoku[row][y] == num)
         {
            return false;
         }
     }
     for( int col = 0; col < sudoku.length; col++)
     {
         if(sudoku[x][col] == num)
         {
             return false;
         }
     }


     for(int box = 3*xSection; box < 3*xSection + 3; box++)
     {
         for(int boxY = 3*ySection; boxY < 3*ySection + 3; boxY++)
         {
             if(sudoku[box][boxY] == num)
             {
                 return false;
             }
         }

     }
     return true;
 }

 private int xPosition(int x, int y)
 {
     if(x<8)
     {
         return x+1;
     }
     else
     {
         return 0;
     }
 }

 private int yPosition(int x, int y)
 {
     if(x<8)
     {
         return y;
     }
     else
     {
         return y+1;
     }
 }
 private boolean solvePuzzle(int x, int y)
 {
     if( x >= 9 || y >= 9)
     {

         return true;
     }

     else
     {
         for(int  num = 1; num < 10; num++)
         {
             if(isValid(x,y,num))
             {
                 sudoku[x][y] = num;
                 if( solvePuzzle(xPosition(x,y), yPosition(x,y)) )
                 {
                     return true;
                 }
                 else
                 {
                     sudoku[x][y] = 0;
                 }

             }


         }
         return false;
     }


 }

finding perfect squares

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

 public class NumOfSqrs {


public static void main(String[] args) {

    try{
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    String input;
    int line = 0;
    int testCases;
    int numOfSqrt = 0;      
    int j = 0;  

    while((input=br.readLine())!=null){

        if(line == 0){
          testCases = Integer.parseInt(input);
          line = line +1;
        }
        else{
          String[] splitter = input.toString().split(" ");

        

           for(int i = Integer.parseInt(splitter[0]); i<=Integer.parseInt(splitter[1]) ; i++){

            String value = ""+Math.sqrt(i);
            String[] isSqrt = value.toString().split("\\.");
         

   
            if(isSqrt[1].length() == 1){
              numOfSqrt++;
            }

          }
          System.out.println(""+numOfSqrt);
        }
     numOfSqrt = 0;
    }


    }catch(IOException io){
        io.printStackTrace();
    }   


  }
}

Wrapping of Streams

A program that demonstrates the wrapping of streams and readers

import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.IOException;
import java.util.Scanner;
import java.util.NoSuchElementException;
 class MaxTest
 {
 public static void main( String [ ] args )
 {
 BufferedReader in = new BufferedReader( new
 InputStreamReader( System.in ) );

 System.out.println( "Enter 2 ints on one line: " );
 try
 {
 String oneLine = in.readLine( );
 if( oneLine == null )
 return;
 Scanner str = new Scanner( oneLine );

 int x = str.nextInt( );
 int y = str.nextInt( );

 System.out.println( "Max: " + Math.max( x, y ) );
 }
 catch( IOException e )
 { System.err.println( "Unexpected I/O error" ); }
 catch( NoSuchElementException e )
 { System.err.println( "Error: need two ints" ); }
 }
 }

Search Sub String

String str = "java search string"; int firstIndex = str.indexOf("java"); System.out.println("First occurrence of char "+ " is found at : " + firstIndex); int lastIndex = str.lastIndexOf("java"); System.out.println("Last occurrence of char java is"+ " found at : " + lastIndex); int first_in = str.indexOf("java", 10); System.out.println("First occurrence of char java"+ " after index 10 : " + first_in); int last_in = str.lastIndexOf("java", 20); System.out.println("Last occurrence of char java " + "after index 20 is : " + last_in); } }