hacktoberfest-2022

ActivitySelection.java

@@ -0,0 +1,51 @@
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class ActivitySelection {
+
+    static class Activity {
+        int start;
+        int end;
+
+        public Activity(int start, int end) {
+            this.start = start;
+            this.end = end;
+        }
+
+        @Override
+        public String toString(){
+            return "[" + this.start + ", " + this.end + "]";
+        }
+    }
+
+    public static void maxActivities(ArrayList<Activity> activities){
+
+        //sort the activities in ascending order of meeting finish time
+        System.out.println("Given Activities: " + activities);
+        Collections.sort(activities, (o1, o2) -> o1.end - o2.end);
+
+        ArrayList<Activity> selectedActivities = new ArrayList<>();
+        int currentEnd = -1;
+        for (int i = 0; i <activities.size() ; i++) {
+            Activity currentActivity = activities.get(i);
+            if(currentActivity.start >currentEnd){
+                selectedActivities.add(currentActivity);
+                currentEnd = currentActivity.end;
+            }
+        }
+
+       //print selected activities
+        System.out.println("Selected Activities: " + selectedActivities);
+    }
+
+    public static void main(String[] args) {
+        ArrayList<Activity> activities = new ArrayList<>();
+        activities.add(new Activity(1, 3));
+        activities.add(new Activity(2, 5));
+        activities.add(new Activity(0, 7));
+        activities.add(new Activity(6, 8));
+        activities.add(new Activity(9, 11));
+        activities.add(new Activity(10, 12));
+        maxActivities(activities);
+    }
+}

Armstrong_Funtion.java

@@ -0,0 +1,48 @@
+import java.io.*;
+class Armstrong_Funtion
+{
+    public int Number(int n)
+    {
+        int r,a=0,ano=n,flag=0;
+        while(n>0)
+        {
+            r = n%10;
+            a = a + (r*r*r);
+            n = (n-r)/10;
+        }
+        if(ano==a)
+        {
+            flag = 1;
+        }
+        else
+        {
+            flag = 0;
+        }
+        return(flag);
+    }
+    public static void main(String args[]) throws IOException
+    {
+        System.out.println("Armstrong Number");
+        System.out.println("****************");
+        System.out.println("");
+        InputStreamReader isr=new InputStreamReader(System.in);
+        BufferedReader br=new BufferedReader(isr);
+        int d,p;
+        System.out.print("Enter Number : ");
+        d = Integer.parseInt(br.readLine());
+        System.out.println("");
+        Armstrong_Funtion ob = new Armstrong_Funtion();
+        p = ob.Number(d);
+        if(p==1)
+        {
+            System.out.println("Number is Armstrong");
+        }
+        else
+        {
+            System.out.println("Number is Not Armstrong");
+        }
+    }
+}    
+
+
+

BinarySearch.java

@@ -45,7 +45,23 @@ public static void main(String[] args) {
      * @param number
      * @return index of given number in array or -1 if not found
      */
-    public static int performBinarySearch(int[] input, int number) {
+//     public static int performBinarySearch(int[] input, int number) {
+//         int low = 0;
+//         int high = input.length - 1;
+
+//         while (high >= low) {
+//             int middle = (low + high) / 2;
+//             if (input[middle] == number) {
+//                 return middle;
+//             } else if (input[middle] < number) {
+//                 low = middle + 1;
+//             } else if (input[middle] > number) {
+//                 high = middle - 1;
+//             }
+//         }
+//         return -1;
+//     }
+                           public static int performBinarySearch(int[] input, int number) {
         int low = 0;
         int high = input.length - 1;
 

Binary_Search.java

@@ -0,0 +1,35 @@
+import java.util.*;
+class Main{  
+ public static void main(String args[]){  
+    int numArray[] = {5,10,15,20,25,30,35}; 
+    System.out.println("The input array: " + Arrays.toString(numArray));
+
+    int key = 20;
+    System.out.println("\nKey to be searched=" + key);
+
+    int first = 0;
+
+    int last=numArray.length-1; 
+
+    int mid = (first + last)/2;  
+
+    while( first <= last ){  
+
+        if ( numArray[mid] < key ){  
+            first = mid + 1;     
+        }else if ( numArray[mid] == key ){ 
+
+            System.out.println("Element is found at index: " + mid);  
+            break;  
+        }else{  
+
+            last = mid - 1;  
+        }  
+        mid = (first + last)/2;  
+   }  
+
+   if ( first > last ){  
+      System.out.println("Element is not found!");  
+   }       
+ }  
+}

BubbleSort.java

@@ -1,4 +1,5 @@
 public class BubbleSortExample {  
+    //worst case of this code is O(n2).
     static void bubbleSort(int[] arr) {  
         int n = arr.length;  
         int temp = 0;  
@@ -13,8 +14,32 @@ static void bubbleSort(int[] arr) {
 
                  }  
          }  
+
 
-    }  
+    } 
+    // An optimized version of Bubble Sort
+    //worst case of this code is O(n).
+    static void optimizedbubbleSort(int arr[], int n)
+    {
+        int i, j, temp;
+        boolean swapped;
+        for (i = 0; i < n - 1; i++)
+        {
+            swapped = false;
+            for (j = 0; j < n - i - 1; j++)
+            {
+                if (arr[j] > arr[j + 1])
+                {
+                    temp = arr[j];
+                    arr[j] = arr[j + 1];
+                    arr[j + 1] = temp;
+                    swapped = true;
+                }
+            }
+            if (swapped == false)
+                break;
+        }
+    }
     public static void main(String[] args) {  
                 int arr[] ={3,60,35,2,45,320,5};  
 
@@ -32,4 +57,4 @@ public static void main(String[] args) {
                 }  
 
         }  
-}  
+}  

BubbleSortExample.java

@@ -0,0 +1,35 @@
+public class BubbleSortExample {  
+    static void bubbleSort(int[] arr) {  
+        int n = arr.length;  
+        int temp = 0;  
+         for(int i=0; i < n; i++){  
+                 for(int j=1; j < (n-i); j++){  
+                          if(arr[j-1] > arr[j]){  
+                                 //swap elements  
+                                 temp = arr[j-1];  
+                                 arr[j-1] = arr[j];  
+                                 arr[j] = temp;  
+                         }  
+
+                 }  
+         }  
+
+    }  
+    public static void main(String[] args) {  
+                int arr[] ={3,60,35,2,45,320,5};  
+
+                System.out.println("Array Before Bubble Sort");  
+                for(int i=0; i < arr.length; i++){  
+                        System.out.print(arr[i] + " ");  
+                }  
+                System.out.println();  
+
+                bubbleSort(arr);//sorting array elements using bubble sort  
+
+                System.out.println("Array After Bubble Sort");  
+                for(int i=0; i < arr.length; i++){  
+                        System.out.print(arr[i] + " ");  
+                }  
+
+        }  
+} 

Count the number of words in a string using HashMap.java

@@ -0,0 +1,23 @@
+import java.util.HashMap;
+
+public class FinalCountWords {
+
+    public static void main(String[] args) {
+        // TODO Auto-generated method stub
+        String str = "You are doing this Code";
+        String[] split = str.split(" ");
+
+                HashMap<String,Integer> map = new HashMap<String,Integer>();
+        for (int i=0; i<split.length; i++) {
+            if (map.containsKey(split[i])) {
+                int count = map.get(split[i]);
+                map.put(split[i], count+1);
+            }
+            else {
+                map.put(split[i], 1);
+            }
+        }
+        System.out.println(map);
+    }
+
+}

CountingSortAlgo.java

@@ -0,0 +1,55 @@
+// Counting sort in Java programming
+
+//import file
+import java.util.Arrays;
+
+class CountingSort {
+  void countSort(int array[], int size) {
+    int[] output = new int[size + 1];
+
+    // For  Finding the largest element of the array
+    int max = array[0];
+    for (int i = 1; i < size; i++) {
+      if (array[i] > max)
+        max = array[i];
+    }
+    int[] count = new int[max + 1];
+
+    // Initialize count array with all zeros
+    for (int i = 0; i < max; ++i) {
+      count[i] = 0;
+    }
+
+    // Store the count of each element
+    for (int i = 0; i < size; i++) {
+      count[array[i]]++;
+    }
+
+    // Store the cummulative count of each array
+    for (int i = 1; i <= max; i++) {
+      count[i] += count[i - 1];
+    }
+
+    // Find the index of each element of the original array in count array, and
+    // place the elements in output array
+    for (int i = size - 1; i >= 0; i--) {
+      output[count[array[i]] - 1] = array[i];
+      count[array[i]]--;
+    }
+
+    // Copy the sorted elements into original array
+    for (int i = 0; i < size; i++) {
+      array[i] = output[i];
+    }
+  }
+
+  // Driver code for the above code
+  public static void main(String args[]) {
+    int[] data = { 4, 2, 2, 8, 3, 3, 1 };
+    int size = data.length;
+    CountingSort cs = new CountingSort();
+    cs.countSort(data, size);
+    System.out.println("Sorted Array in Ascending Order: ");
+    System.out.println(Arrays.toString(data));
+  }
+}

DNFSort.java

@@ -0,0 +1,49 @@
+public class DNFSort {
+
+    // Sort the input array, the array is assumed to
+    // have values in {0, 1, 2}
+    static void sort012(int a[], int arr_size) {
+        int low = 0;
+        int high = arr_size - 1;
+        int mid = 0, temp = 0;
+        while (mid <= high) {
+            switch (a[mid]) {
+                case 0: {
+                    temp = a[low];
+                    a[low] = a[mid];
+                    a[mid] = temp;
+                    low++;
+                    mid++;
+                    break;
+                }
+                case 1:
+                    mid++;
+                    break;
+                case 2: {
+                    temp = a[mid];
+                    a[mid] = a[high];
+                    a[high] = temp;
+                    high--;
+                    break;
+                }
+            }
+        }
+    }
+
+    /* Utility function to print array arr[] */
+    static void printArray(int arr[], int arr_size) {
+        for (int i = 0; i < arr_size; i++) {
+            System.out.print(arr[i] + " ");
+        }
+        System.out.println("");
+    }
+
+    /*Driver function to check for above functions*/
+    public static void main(String[] args) {
+        int arr[] = {0, 1, 1, 0, 1, 2, 1, 2, 0, 0, 0, 1};
+        int arr_size = arr.length;
+        sort012(arr, arr_size);
+        System.out.println("Array after seggregation ");
+        printArray(arr, arr_size);
+    }
+}