test your brain

https://www.youtube.com/watch?v=bEU9dkOG7co&feature=youtu.be

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);
    }
}