Day 8

Author: alitinart

ch-21/src/CountKeywords.java

@@ -0,0 +1,2 @@
+package PACKAGE_NAME;public class CountKeywords {
+}

ch-21/src/DisplayNonDuplicate.java

@@ -0,0 +1,2 @@
+public class DisplayNonDuplicate {
+}

ch-21/src/GuessCapitalsGame.java

@@ -0,0 +1,2 @@
+package PACKAGE_NAME;public class GuessCapitalsGame {
+}

ch-21/src/NumberOfOccurrences.java

@@ -0,0 +1,2 @@
+package PACKAGE_NAME;public class NumberOfOccurrences {
+}

ch-21/src/file.txt

@@ -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-22/.gitignore

@@ -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-22/.idea/.gitignore

@@ -0,0 +1,58 @@
+import java.util.Scanner;
+
+/**
+ *
+ * *22.1 (Maximum consecutive increasingly ordered substring)
+
+ * Write a program that
+ * prompts the user to enter a string and displays the maximum consecutive
+ * increasingly ordered substring. Analyze the time complexity of your program.
+ *
+ */
+
+// Code below has a time complexity of O(n^2)
+
+public class ConsecutiveSubstring {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.println("Enter a sequence of strings: ");
+        String sequence = scanner.nextLine();
+
+        String longestSequence = "";
+        String sortedSequence = "";
+        int start = 0;
+        for(int i = 0; i < sequence.length() + 1; i++) {
+            sortedSequence = sequence.substring(start, i);
+            if(!isAlphabetical(sortedSequence)){
+                start = i - 1;
+                if(sortedSequence.length() > longestSequence.length()) {
+                    longestSequence = sortedSequence.substring(0, sortedSequence.length() - 1);
+                    continue;
+                }
+
+                sortedSequence = "";
+            }
+
+            if(sortedSequence.length() > longestSequence.length()) {
+                longestSequence = sortedSequence;
+            }
+        }
+
+        System.out.println("Longest Sequence in string is: " + longestSequence);
+    }
+
+    public static boolean isAlphabetical(String s) {
+        char[] charArray = s.toCharArray();
+
+        for(int i = 1; i < charArray.length; i++) {
+            char current = charArray[i];
+            char previous = charArray[i - 1];
+            if(current < previous) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
+

ch-22/.idea/misc.xml

@@ -0,0 +1,41 @@
+import java.util.Scanner;
+
+/**
+ *
+ * *22.3 (Pattern matching)
+
+ * Write a program that prompts the user to enter two strings
+ * and tests whether the second string is a substring of the first string. Suppose
+ * the neighboring characters in the string are distinct. (Don’t use the indexOf
+ * method in the String class.) Analyze the time complexity of your algorithm.
+ * Your algorithm needs to be at least O(n) time.
+ *
+ */
+public class PatternMatching {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.println("Enter string number one: ");
+        String s1 = scanner.nextLine();
+        System.out.println("Enter string number two");
+        String s2 = scanner.nextLine();
+
+        String currentPattern = "";
+        int startIndex = -1;
+        for(int i = 0; i < s1.length(); i++) {
+            if(currentPattern.equals(s2)) {
+                break;
+            }
+            char s1Char = s1.charAt(i);
+            if(s1Char == s2.charAt(currentPattern.length())) {
+                if(startIndex == -1)
+                    startIndex = i;
+                currentPattern += s1Char;
+                continue;
+            }
+            currentPattern = "";
+            startIndex = -1;
+        }
+
+        System.out.println("Pattern starts at index: " + startIndex);
+    }
+}

ch-22/.idea/modules.xml

@@ -0,0 +1,81 @@
+import java.io.*;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+/**
+ *
+ * **22.8 (All prime numbers up to 10,000,000,000)
+
+ * Write a program that finds
+ * all prime numbers up to 10,000,000,000. There are approximately
+ * 455,052,511 such prime numbers. Your program should meet the following
+ * requirements:
+
+ * ■ Your program should store the prime numbers in a binary data file, named
+     * PrimeNumbers.dat. When a new prime number is found, the number is
+     * appended to the file.
+
+ * ■ To find whether a new number is prime, your program should load the
+     * prime numbers from the file to an array of the long type of size 10000.
+     * If no number in the array is a divisor for the new number, continue to read
+     * the next 10000 prime numbers from the data file, until a divisor is found
+     * or all numbers in the file are read. If no divisor is found, the new number
+     * is prime.
+
+ * ■ Since this program takes a long time to finish, you should run it as a batch
+     * job from a UNIX machine. If the machine is shut down and rebooted, your
+     * program should resume by using the prime numbers stored in the binary data
+     * file rather than start over from scratch.
+ *
+ */
+public class PrimeNumbers {
+    public static void main(String[] args) {
+        long startNumber = 2;
+        long maxNumber = 10_000_000_000L;
+        List<Long> primes = loadStoredPrimes();
+
+        for (long num = startNumber; num <= maxNumber; num++) {
+            if (isPrime(num, primes)) {
+                storePrime(num);
+                primes.add(num);
+            }
+        }
+    }
+
+    public static List<Long> loadStoredPrimes() {
+        List<Long> primes = new ArrayList<>();
+
+        try(
+                Scanner scanner = new Scanner(new File("PrimeNumbers.dat"))
+                ) {
+            while (scanner.hasNextLong()) {
+                primes.add(scanner.nextLong());
+            }
+        } catch (FileNotFoundException ex) {
+            System.out.println("File was not found");
+        }
+        return primes;
+    }
+
+    public static boolean isPrime(long num, List<Long> primes) {
+        for (long prime : primes) {
+            if (prime * prime > num) {
+                break;
+            }
+            if (num % prime == 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static void storePrime(long prime) {
+        try (DataOutputStream dos = new DataOutputStream(new FileOutputStream("PrimeNumbers.dat", true))) {
+            dos.writeLong(prime);
+        } catch (IOException ex) {
+            System.out.println("Error writing to file: " + ex.getMessage());
+        }
+    }
+}