Day 6

Author: alitinart

ch-18/.idea/vcs.xml

@@ -0,0 +1,29 @@
+import java.util.Scanner;
+
+/**
+ *
+ * Case Study: Compute Factorials
+
+ * 0! = 1;
+ * n! = n × (n - 1)!; n > 0
+ *
+ */
+public class ComputeFactorials {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.println("Compute factorial of the number: ");
+        int n = scanner.nextInt();
+
+        System.out.println(n + " factorial is equal to: " + computeFactorial(n));
+    }
+
+    public static int computeFactorial(int n) {
+        if(n == 0) {
+            return 1;
+        } else if (n == 1) {
+            return 1;
+        } else {
+            return n * computeFactorial(n - 1);
+        }
+    }
+}

ch-18/src/ComputeFactorials.java

@@ -0,0 +1,33 @@
+import java.util.Scanner;
+
+/**
+ *
+ * *18.3 (Compute greatest common divisor using recursion)
+
+ * The gcd(m, n) can also
+ * be defined recursively as follows:
+ *  ■ If m % n is 0, gcd(m, n) is n.
+ *  ■ Otherwise, gcd(m, n) is gcd(n, m % n).
+ *  Write a recursive method to find the GCD. Write a test program that prompts the
+ * user to enter two integers and displays their GCD.
+ *
+ */
+public class ComputeGCD {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.println("Enter first number:");
+        int m = scanner.nextInt();
+        System.out.println("Enter second number: ");
+        int n = scanner.nextInt();
+
+        System.out.println("GCD: " + computeGCD(m, n));
+    }
+
+    public static int computeGCD(int m, int n) {
+        if(m % n == 0) {
+            return n;
+        } else {
+            return computeGCD(n, m % n);
+        }
+    }
+}

ch-18/src/ComputeGCD.java

@@ -0,0 +1,34 @@
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.Scanner;
+
+/**
+ *
+ * Case Study: Find Directory Size
+ *
+ */
+public class FindDirectorySize {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.println("Enter directory path: ");
+        File dir = new File(scanner.nextLine());
+
+        System.out.println("Directory has a total size of: " + getDirSize(dir));
+    }
+
+    public static long getDirSize(File dir) {
+        long count = 0;
+        if(!dir.isDirectory()) {
+            count += dir.length();
+        }
+
+        File[] fileList = dir.listFiles();
+
+        for(int i = 0; fileList != null && i < fileList.length; i++) {
+            count += getDirSize(fileList[i]);
+        }
+
+        return count;
+    }
+}

ch-18/src/FindDirectorySize.java

@@ -0,0 +1,30 @@
+import java.util.Scanner;
+
+/**
+ *
+ * *18.9 (Print the characters in a string reversely)
+
+ * Write a recursive method that displays a string reversely on the console using the following header:
+ * public static void reverseDisplay(String value)
+ *  For example, reverseDisplay("abcd") displays dcba. Write a test program
+ * that prompts the user to enter a string and displays its reversal
+ *
+ */
+public class ReverseString {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.println("Enter string to reverse: ");
+        String s = scanner.nextLine();
+
+        reverseDisplay(s);
+    }
+
+    public static void reverseDisplay(String value){
+        if (value.length() == 0) {
+            return;
+        } else {
+            System.out.print(value.charAt(value.length() - 1));
+            reverseDisplay(value.substring(0, value.length() - 1));
+        }
+    }
+}

ch-18/src/Main.java

@@ -0,0 +1,41 @@
+import java.util.Arrays;
+import java.util.Scanner;
+
+/**
+ *
+ * **18.25 (String permutation)
+ * Write a recursive method to print all the permutations of a
+ * string. For example, for the string abc, the permuation is
+ * abc
+ * acb
+ * bac
+ * bca
+ * cab
+ * cba
+ *
+ */
+public class StringPermutation {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.print("Enter a string: ");
+        String input = scanner.nextLine();
+        displayPermutation(input);
+    }
+
+    public static void displayPermutation(String s) {
+        displayPermutation("", s);
+    }
+
+    public static void displayPermutation(String s1, String s2) {
+        if (s2.isEmpty()) {
+            System.out.println(s1);
+        } else {
+            for (int i = 0; i < s2.length(); i++) {
+                char currentChar = s2.charAt(i);
+                String newS1 = s1 + currentChar;
+                String newS2 = s2.substring(0, i) + s2.substring(i + 1);
+                displayPermutation(newS1, newS2);
+            }
+        }
+    }
+}

ch-18/src/ReverseString.java

@@ -0,0 +1,29 @@
+### IntelliJ IDEA ###
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store

ch-18/src/StringPermutation.java

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

ch-19/.gitignore

@@ -0,0 +1,27 @@
+public class BinarySearch {
+    public static void main(String[] args) {
+        Integer[] integers = {1,2,3,4,5,6,7,8,9,10};
+        System.out.println("Index of key is: " + binarySearch(integers, 4));
+    }
+
+    public static <E extends Comparable<E>> int binarySearch(E[] list, E key) {
+        int low = 0;
+        int high = list.length - 1;
+        boolean found = false;
+        int keyIndex = -1;
+
+        while(!found) {
+            int mid = (low + high) / 2;
+            if(list[mid].compareTo(key) == 0) {
+                keyIndex = mid;
+                found = true;
+            } else if (list[mid].compareTo(key) > 0) {
+                high = mid - 1;
+            } else {
+                low = mid + 1;
+            }
+        }
+
+        return keyIndex;
+    }
+}

ch-19/.idea/.gitignore

@@ -0,0 +1,54 @@
+/**
+ *
+ * Case Study: Sorting an array of comparable objects
+ *
+ */
+public class ComparableSort {
+    public static void main(String[] args) {
+        Integer[] intArray = {1,2,3,4,5};
+        Double[] doubleArray = {3.4,1.3,-22.1};
+        Character[] charArray = {'a', 'j', 'r'};
+        String[] stringArray = {"Tom", "Susan", "Kim"};
+
+        sort(intArray);
+        sort(doubleArray);
+        sort(charArray);
+        sort(stringArray);
+
+        System.out.println("Sorted Integer array: ");
+        printList(intArray);
+        System.out.println("Sorted Double array: ");
+        printList(doubleArray);
+        System.out.println("Sorted Char array: ");
+        printList(charArray);
+        System.out.println("Sorted String array: ");
+        printList(stringArray);
+    }
+
+    public static <E extends Comparable<E>> void sort(E[] list) {
+        E currentMin;
+        int currentMinIndex;
+
+        for(int i = 0; i < list.length; i++) {
+            currentMin = list[i];
+            currentMinIndex = i;
+
+            for(int j = i + 1; j < list.length; j++){
+                if(currentMin.compareTo(list[j]) > 0) {
+                    currentMin = list[j];
+                    currentMinIndex = j;
+                }
+            }
+
+            if(currentMinIndex != i) {
+                list[currentMinIndex] = list[i];
+                list[i] = currentMin;
+            }
+        }
+    }
+
+    public static void printList(Object[] list) {
+        for (Object o : list) System.out.print(o + " ");
+        System.out.println();
+    }
+}

ch-19/.idea/misc.xml

@@ -0,0 +1,40 @@
+import java.util.ArrayList;
+
+/**
+ *
+ * 19.3 (Distinct elements in ArrayList)
+
+ * Write the following method that returns a new
+ * ArrayList. The new list contains the non-duplicate elements from the original list.
+ *
+ */
+public class DistinctElements {
+    public static void main(String[] args) {
+        ArrayList<Integer> integers = new ArrayList<Integer>() {
+            {
+                add(1);
+                add(1);
+                add(2);
+                add(3);
+                add(2);
+                add(4);
+            }
+        };
+
+        integers = removeDuplicates(integers);
+
+        System.out.println(integers);
+    }
+
+    public static <E> ArrayList<E> removeDuplicates(ArrayList<E> list) {
+        ArrayList<E> newList = new ArrayList<>();
+
+        for(E o: list) {
+            if (!newList.contains(o)) {
+                newList.add(o);
+            }
+        }
+
+        return newList;
+    }
+}