[Shivani] : added algorithm problems

Author: Shipramargurate

src/com/bridgelabz/Anagram.java

@@ -0,0 +1,45 @@
+package com.bridgelabz;
+
+import java.util.*;
+/*
+ * 6. An Anagram Detection Example
+ *  	a. Desc -> One string is an anagram of another if the second is simply 
+ *			    	a rearrangement of the first. For example, 'heart' and 'earth' are anagrams...
+ *		b. I/P -> Take 2 Strings as Input such abcd and dcba and Check for Anagrams
+ *		c. O/P -> The Two Strings are Anagram or not....
+ */
+public class Anagram {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		// taking two strings for two words
+		System.out.println("Enter the first word");
+		String str1 = sc.nextLine();
+		System.out.println("Enter the second word");
+		String str2 = sc.nextLine();
+		// lower case
+		str1 = str1.toLowerCase();
+		str2 = str2.toLowerCase();
+		// Checking length of two string
+		if (str1.length() == str2.length()) {
+			// if length are same this block willl execute
+			// convert string into char array
+			char[] charArray1 = str1.toCharArray();
+			char[] charArray2 = str2.toCharArray();
+			// if sorted array is same, string is anagram
+			Arrays.sort(charArray1);
+			Arrays.sort(charArray2);
+			// checking two are same or not if true if block will execute or else will
+			boolean result = Arrays.equals(charArray1, charArray2);
+			if (result) {
+				System.out.println(str1 + "  and  " + str2 + " are anagram");
+			} else {
+				System.out.println(str1 + "   and  " + str2 + "  not anagram");
+			}
+		} else {
+			// if length of two string not equal this block will execute
+			System.out.println("invalid word");
+		}
+		sc.close();
+	}
+}

src/com/bridgelabz/BinaryTree.java

@@ -0,0 +1,48 @@
+package com.bridgelabz;
+
+import java.util.*;
+
+public class BinaryTree {
+	static Scanner sc = new Scanner(System.in);
+
+	int Search(int arr[], int l, int r, int x) {
+		if (r >= l) {
+			int mid = l + (r - l) / 2;
+
+			if (arr[mid] == x) // element is present at the mid
+			{
+				return mid;
+			}
+			//  If element is smaller than mid, then it is present in left subarray
+			if (arr[mid] > x)
+				return Search(arr, l, mid - 1, x);
+			else
+				return Search(arr, mid + 1, r, x); // element present in right subarray
+		}
+
+		return -1; // element is not present
+	}
+
+	public static void main(String[] args) {
+		BinaryTree bTree = new BinaryTree();
+		System.out.println("Enter the no of elements: ");
+		int n = sc.nextInt();
+		int[] arr = new int[n];
+		System.out.println("enter elements of binary tree");
+		for (int i = 0; i < arr.length; i++) {
+			arr[i] = sc.nextInt();
+		}
+		System.out.println("elemets are : ");
+		for (int i = 0; i < arr.length; i++) {
+			System.out.println(arr[i]);
+		}
+		System.out.println("enter value for x");
+		int x = sc.nextInt();
+		int result = bTree.Search(arr, 0, n - 1, x);
+		if (result == -1)
+			System.out.println("Element not found");
+		else
+			System.out.println("Element found at index " + result);
+	}
+
+}

src/com/bridgelabz/BubbleSort.java

@@ -0,0 +1,39 @@
+package com.bridgelabz;
+
+public class BubbleSort {
+	/*
+	 * 4. Bubble Sort
+     *    a. Desc -> Reads in integers prints them in sorted order using Bubble Sort
+     *    b. I/P -> read in the list ints
+	 *	  c. O/P -> Print the Sorted List
+	 */
+
+	public void bubbleSort() {
+		int[] a = { 9, 20, 55, 79, 44, 68, 66, 54, 35, 37, 25 };
+
+		// for loop for printing the elements of an array
+		System.out.println("Elements of array are :");
+		for (int i = 0; i < a.length; i++) {
+			System.out.print(" " + a[i] + " ");
+		}
+		// nested for loop for bubble sort operation
+		for (int i = 0; i < a.length; i++) {
+			for (int j = 0; j < a.length - i - 1; j++) {
+				if (a[j] > a[j + 1]) {
+					int temp = a[j];
+					a[j] = a[j + 1];
+					a[j + 1] = temp;
+				}
+			}
+		}
+		System.out.println("\nElements of array after bubble sort is :");
+		for (int i = 0; i < a.length; i++) {
+			System.out.print(" " + a[i] + " ");
+		}
+	}
+
+	public static void main(String[] args) {
+		BubbleSort bs = new BubbleSort();
+		bs.bubbleSort();
+	}
+}

src/com/bridgelabz/InsertionSort.java

@@ -0,0 +1,36 @@
+package com.bridgelabz;
+
+public class InsertionSort {
+	/*
+	 * 3. Insertion Sort
+	 *		a. Desc -> Reads in strings and prints them in sorted order using insertion sort.
+	 *		b. I/P -> read in the list words
+	 *		c. Logic -> Use Insertion Sort to sort the words in the String array
+	 * 		d. O/P -> Print the Sorted List
+	 */
+	public void sort(String[] arr) {
+		for (int i = 1; i < arr.length; ++i) {
+			String key = arr[i];
+			int j = i - 1;
+			while (j >= 0 && key.length() < arr[j].length()) {
+				arr[j + 1] = arr[j];
+				j = j - 1;
+			}
+			arr[j + 1] = key;
+		}
+		for (int i = 0; i < arr.length; i++) {
+			System.out.print(arr[i] + " ");
+		}
+	}
+
+	public static void main(String[] args) {
+		InsertionSort ob = new InsertionSort();
+		String[] arr = { "Somiya", "is", "a", "good", "Girl" };
+		System.out.println("Before:");
+		for (int i = 0; i < arr.length; i++) {
+			System.out.print(arr[i] + " ");
+		}
+		System.out.println("\nAfter: ");
+		ob.sort(arr);
+	}
+}

src/com/bridgelabz/MergeSort.java

@@ -0,0 +1,77 @@
+package com.bridgelabz;
+
+public class MergeSort {
+
+/*
+ * 5. Merge Sort - Write a program to do Merge Sort of list of Strings.
+ *		a. Logic -> To Merge Sort an array, we divide it into two halves, sort the two halves
+ *					independently, and then merge the results to sort the full array. To sort a[lo, hi),
+ *					we use the following recursive strategy:
+ *		b. Base case: If the subarray length is 0 or 1, it is already sorted.
+ *		c. Reduction step: Otherwise, compute mid = lo + (hi - lo) / 2, recursively sort the
+ *					two subarrays a[lo, mid) and a[mid, hi), and merge them to produce a sorted
+ *					result.
+ */
+    public void displayArray(int arr[], int n){
+        for (int i=0; i<n; i++){
+            System.out.print(arr[i]+" ");
+        }
+        System.out.println();
+    }
+    /*
+     * Divie array to sub arrays and merge to function
+     */
+    public void splitAndMerge(int arr[], int low, int high){
+        if (low<high){
+            int mid = (low+high) / 2;
+            splitAndMerge(arr, low, mid);
+            splitAndMerge(arr, mid+1, high);
+            merge(arr, low, mid, high);
+        }
+    }
+    /*
+     * merge divided arrays to function
+     */
+    public void merge(int arr[], int low, int mid, int high){
+        int i = low, h = low, j = mid+1, k, temp[] = new int[10];
+        while (h<=mid && j<=high){
+            if (arr[h] <= arr[j]){
+                temp[i] = arr[h];
+                h++;
+            }else {
+                temp[i] = arr[j];
+                j++;
+            }
+            i++;
+        }
+        if (h>mid){
+            for (k=j; k<=high; k++){
+                temp[i] = arr[k];
+                i++;
+            }
+        }else {
+            for (k=h; k<= mid; k++){
+                temp[i] = arr[k];
+                i++;
+            }
+        }
+        for (k=low; k<=high; k++){
+            arr[k] = temp[k];
+        }
+    }
+    public static void main(String[] args)
+    {
+        MergeSort mergSort = new MergeSort();
+        int arr[] = {48, 93, 28, 44, 1, 0, -1, 3};
+        int len = arr.length;
+        System.out.println("Before MergeSort the array elements : ");
+        mergSort.displayArray(arr, len);
+        /*
+         * Dividing array to sub arrays
+         */
+        mergSort.splitAndMerge(arr, 0, len-1);
+        System.out.println("After MergeSort the array elements : ");
+        mergSort.displayArray(arr, len);
+
+    }
+}

src/com/bridgelabz/PermutationOfString.java

@@ -0,0 +1,44 @@
+package com.bridgelabz;
+
+public class PermutationOfString {
+/*
+ * Write static functions to return all permutations of a String using iterative method and
+ * Recursion method. Check if the arrays returned by two string functions are equal.
+ */
+	static int count = 0;
+
+	public static void main(String[] args) {
+		String str = "ABCD";
+		int n = str.length();
+		PermutationOfString permutation = new PermutationOfString();
+		permutation.permutate(str, 0, n - 1);
+		System.out.println("Number of permutactions for the given string is " + count);
+	}
+
+	private void permutate(String str, int firstIndex, int lastIndex) {
+
+		if (firstIndex == lastIndex) {
+			System.out.println(str);
+			count++;
+		} else {
+			for (int i = firstIndex; i <= lastIndex; i++) {
+				str = swap(str, firstIndex, i);
+				permutate(str, firstIndex + 1, lastIndex);
+				str = swap(str, firstIndex, i);
+			}
+		}
+	}
+
+	public String swap(String a, int i, int j) {
+		char temp;
+
+		char[] charArray = a.toCharArray();
+
+		temp = charArray[i];
+		charArray[i] = charArray[j];
+		charArray[j] = temp;
+
+		return String.valueOf(charArray);
+	}
+
+}

src/com/bridgelabz/PrimeNumber.java

@@ -0,0 +1,22 @@
+package com.bridgelabz;
+
+public class PrimeNumber {
+//Take a range of 0 - 1000 Numbers and find the Prime numbers in that range.
+	public static boolean isPrime(int n) {
+		if (n < 2)			// if n is less than 2 it will return false
+			return false;
+		for (int i = 2; i < n; i++) {
+			if (n % i == 0)
+				return false;
+		}
+		return true;
+	}
+	public static void main(String[] args) {
+		int lower = 0;
+		int upper = 1000;
+		System.out.println("Prime numbers between 0 to 1000 are "); // printing prime numbers till 1000
+		for (int i = lower; i <= upper; i++)
+			if (isPrime(i))
+				System.out.println(i);
+	}
+}