From 6b620cf0a1ff693e27f225d266e1f32b38e44886 Mon Sep 17 00:00:00 2001 From: Jonathan Turner Date: Wed, 24 Jan 2024 01:04:02 -0500 Subject: [PATCH] Refactered into subfolders. --- src/AnagramsCheck.java | 2 - src/Assignment1/AnagramsCheck.java | 224 +++++++++++++++++++++++++++++ src/Assignment1/LockerDoors.java | 219 ++++++++++++++++++++++++++++ src/LockerDoors.java | 50 ------- 4 files changed, 443 insertions(+), 52 deletions(-) delete mode 100644 src/AnagramsCheck.java create mode 100644 src/Assignment1/AnagramsCheck.java create mode 100644 src/Assignment1/LockerDoors.java delete mode 100644 src/LockerDoors.java diff --git a/src/AnagramsCheck.java b/src/AnagramsCheck.java deleted file mode 100644 index 3931b1d..0000000 --- a/src/AnagramsCheck.java +++ /dev/null @@ -1,2 +0,0 @@ -package PACKAGE_NAME;public class AnagramsCheck { -} diff --git a/src/Assignment1/AnagramsCheck.java b/src/Assignment1/AnagramsCheck.java new file mode 100644 index 0000000..71d4f0c --- /dev/null +++ b/src/Assignment1/AnagramsCheck.java @@ -0,0 +1,224 @@ +// Name: Jonathan Turner +// Class: CS 4306/01 +// Term: Spring 2024 +// Instructor: Dr. Haddad +// Assignment: 1 +// IDE Name: IntelliJ +/* +Algorithm Design Block + Algorithm title: String Anagram Checker + + + Logical steps: + Step 1: Gather user input for the two separate values to check and save these as Strings. + Step 2: Remove Cases and Spaces from the Strings by using replaceAll and toLowerCase. + Step 3: Convert the strings to two separate Char Arrays using toChar (A1 and A2). + Step 4: Check the length of those Arrays, if they are different they are not anagrams and stop algorithm. + Step 5: Create an outer (i) and inner (j) for loop that goes to the length of the array lengths (n). + Step 6: Compare the A1[i] to A2[j], if value is the same mark A2[j] empty (' ') and increment comparisons. + Step 7: After the for loops, make a boolean value to check if it is an anagram and set it to true. + Step 8: Loop through A2, if there is a non-null value then they are not anagrams. + + + Pseudocode Syntax: + word1_string <- input + word2_string <- input + + removeSpaces(word1_string) + removeCases(word1_string) + + removeSpaces(word2_string) + removeCases(word2_string) + + first_word <- word1_string.toChar + second_word <- word2_string.toChar + + if first_word.length != second_word.length + return False + + for i <- 1 to first_word + for j <- 1 to second_word + if first_word[i] = second_word[j] // Basic Operation + second_word[j] <- ' '; + break; + end + end + + result <- True + for i <- 1 to second_word + if second_word[i] != ' ' + result <- false + end + + return result + +*/ +package Assignment1; + +import java.util.Scanner; + +public class AnagramsCheck { + + public static void main(String[] args) { + AnagramsCheck program = new AnagramsCheck(); + program.start(); + } + + private String first; + private String second; + private int comparisons; + + public void start() { + int option = getOption(); + while (option != 3) { + executeOption(option); + option = getOption(); + } + } + + /** + * Prints out the menu of options, asks for an input, and if that input is invalid it prints an error and + * prompts the user again for the input. + */ + private int getOption() { + displayMenu(); // Prints out the menu + + // Asks for the option and begins the loop until a valid option is gathered. + System.out.print("Enter option number: "); + int input = getIntegerInput(); + while (input < 1 || input > 3) { // Compares it to the valid options available. + System.out.println("\nPlease enter a valid input."); + System.out.print("Enter option number: "); + input = getIntegerInput(); + } + System.out.println(); + return input; + } + + /** + * Gets user input to a number. A prompt must be provided prior to running this method. + * If the input was not an integer/(unable to be autoboxed), returns -1. + */ + private int getIntegerInput() { + Scanner sc = new Scanner(System.in); + try { + String textInput = sc.nextLine(); + return Integer.parseInt(textInput); + } catch (Exception e) { + return -1; + } + } + + /** + * Displays the menu options. + */ + private void displayMenu() { + System.out.println("-----------------MAIN MENU--------------"); + System.out.println("1. Read input string1 and string2"); + System.out.println("2. Run algorithm and display output"); + System.out.println("3. Exit program"); + System.out.println(); + } + + /** + * Executs the option that is provided in the parameters. + */ + private void executeOption(int option) { + if (option == 1) { // Gets user input and sets the two strings. + + // Gets the first and second string as input. + first = getString("first"); + System.out.println(); + second = getString("second"); + + } else if (option == 2) { // Preforms the algorithm and displays the results. + + // Checks if the strings have been set prior to performing the algorithm + if (first == null || first.isEmpty() || + second == null || second.isEmpty()) { + System.out.println("Please enter in the two strings prior to performing the algorithm.\n"); + return; + } + + // Performs the algorithm and gathers results + boolean result = performAlgorithm(); + String output = "Output: "; + if (result) { + output += "Strings are anagrams"; + } else { + output += "Strings are not anagrams"; + } + + // Prints results + System.out.println("String 1: " + first); + System.out.println("String 2: " + second); + System.out.println(output); + System.out.println("Comparisons: " + comparisons); + } + System.out.println(); + } + + private String getString(String name) { + System.out.println("Enter the " + name + " string."); + System.out.print("String: "); + Scanner sc = new Scanner(System.in); + String input = sc.nextLine(); + + while (input == null || input.isEmpty()) { + System.out.println("Please enter a valid string."); + System.out.print("String: "); + input = sc.nextLine(); + } + + return input; + } + + + /** + * Performs the algorithm in checking if two strings are anagrams. + * It accomplishes this by first removing casing and spacing from the strings. + * + * Next it will go through two nested loops to see if each character from the first string + * is inside the second string, if it is it sets the value to null. + * + * Lastly it loops through the second string to see if there are any non-null values, + * if there is it returns false. + */ + private boolean performAlgorithm() { + + // Removes the casing and spaces and sets each word in a char array. + char[] first_word = first.toLowerCase().replaceAll(" ", "").toCharArray(); + char[] second_word = second.toLowerCase().replaceAll(" ", "").toCharArray(); + + comparisons = 0; + + /* + Checks if these two strings had the same number of non-whitespace characters. + If not, they're not anagrams. + */ + if (first_word.length != second_word.length) { + return false; + } + + // Loops through all the characters in the first (i) and second (j) word. + for (int i = 0; i < first_word.length; i++) { + for (int j = 0; j < second_word.length; j++) { + comparisons++; // Counts the number of basic operations + if (first_word[i] == second_word[j]) { // Basic Operation + second_word[j] = ' '; + break; + } + } + } + + // Checks if there is any characters that were not set to ' ', if so not all characters matched. + boolean valid = true; + for (int i = 0; i < second_word.length; i++) { + if (second_word[i] != ' ') { + valid = false; + break; + } + } + return valid; + } +} diff --git a/src/Assignment1/LockerDoors.java b/src/Assignment1/LockerDoors.java new file mode 100644 index 0000000..95c2777 --- /dev/null +++ b/src/Assignment1/LockerDoors.java @@ -0,0 +1,219 @@ +// Name: Jonathan Turner +// Class: CS 4306/01 +// Term: Spring 2024 +// Instructor: Dr. Haddad +// Assignment: 1 +// IDE Name: IntelliJ +/* +Algorithm Design Block + Algorithm title: Assignment1.Locker Doors Problem + + Logical steps: + Step 1: Declare two fields, An Array of Assignment1.Locker & A Comparisons Integer. + Step 2: Gather user input for the number of lockers in the problem. + Step 3: Start the locker swap. Check if the input has been gathered prior to execution, if not stop and revert to Step 2. + Step 4: Set comparisons to 0. + Step 5: Start the outer loop (i) that begins at 1 and ends at n, incremented by 1. + Step 6: Start the inner loop (j) that begins at base and ends at n, incremented by the i. (j+=i) + Step 7: Check lockers[j], if open close it, if closed open it. + Step 8: Inside the j loop, increment comparisons by 1. + Step 9: After running the locker swapping, check which lockers are open and closed. + Step 10: Print out N, lockers that are open, lockers that are closed, and the comparisons. + + Pseudocode Syntax: + size <- input + locker <- new locker[input] + comparisons <- 0 + for i <- 1 to n + for j <- i to n by j+=i + if locker[j] is False // Basic Operation + locker[j] <- True + else + locker[i] <- False + comparisons++ + end + end + + open_lockers <- {} + closed_lockers <- {} + for i <- 1 to n + if locker[i] is False + closed_lockers.add(i) + else + open_lockers.add(i) + end + + print("Number of Lockers: " + size) + print("Open lockers: " + open_lockers) + print("Closed lockers: " + closed_lockers) + print("Comparisons: " + comparisons) +*/ +package Assignment1; + +import java.util.Scanner; + +public class LockerDoors { + /** + * Starts the program and begins the sentinel loop. + */ + public static void main(String[] args) { + LockerDoors program = new LockerDoors(); + program.start(); + } + + // The Field Variables + private Locker[] lockers; + private int comparisons; + + /** + * Controls the sentinal loop. Begins with getting an option, executing it, and repeating. + * Only exits when option is 3. + */ + public void start() { + int option = getOption(); + while (option != 3) { + executeOption(option); + option = getOption(); + } + } + + + /** + * Prints out the menu of options, asks for an input, and if that input is invalid it prints an error and + * prompts the user again for the input. + */ + private int getOption() { + displayMenu(); // Prints out the menu + + // Asks for the option and begins the loop until a valid option is gathered. + System.out.print("Enter option number: "); + int input = getIntegerInput(); + while (input < 1 || input > 3) { // Compares it to the valid options available. + System.out.println("\nPlease enter a valid input."); + System.out.print("Enter option number: "); + input = getIntegerInput(); + } + System.out.println(); + return input; + } + + /** + * Gets user input to a number. A prompt must be provided prior to running this method. + * If the input was not an integer/(unable to be autoboxed), returns -1. + */ + private int getIntegerInput() { + Scanner sc = new Scanner(System.in); + try { + String textInput = sc.nextLine(); + return Integer.parseInt(textInput); + } catch (Exception e) { + return -1; + } + } + + + /** + * This method executes the option based on that which was provided in the parameters. + * This method prevents any option from running (Ex. Option 2) until all preconditions have been met. + * Such as setting a size of lockers prior to running the algorithm on the lockers. + */ + private void executeOption(int option) { + if (option == 1) { // Sets the size of lockers based on user input. + System.out.print("Enter the number of lockers: "); + int input = getIntegerInput(); // Gets the user's input for the number of lockers + + // If the input is non-positive then it loops until a positive value is presented. + while (input < 1) { + System.out.println("\nPlease enter a valid number of lockers."); + System.out.print("Enter the number of lockers: "); + input = getIntegerInput(); + } + + // Initializes the lockers field to the provided input size. + lockers = new Locker[input]; + } else if (option == 2) { // Runs the algorithm on the method and prints out the result. + + // Checks if the number of lockers were set or not. + if (lockers == null) { + System.out.println("Please enter a number of lockers prior to running the algorithm.\n"); + return; // Stops the algorithm from running on a null array. + } + + // Sets all the lockers to closed and initializes all variables. + for (int i = 0; i < lockers.length; i++) { + lockers[i] = new Locker(); + } + + performAlgorithm(); // Starts the locker problem algorithm. + + // Calculates the statistics (Comparison, open/closed lockers) + String openLockers = ""; + String closedLockers = ""; + + for (int i = 1; i <= lockers.length; i++) { + if (lockers[i-1].isOpen) { + openLockers += i + " "; + } else { + closedLockers += i + " "; + } + } + + // Prints the output. + System.out.println("Number of lockers: " + lockers.length); + System.out.println("Open lockers: " + openLockers); + System.out.println("Closed lockers: " + closedLockers); + System.out.println("Comparisons: " + comparisons); + } + + System.out.println(); + } + + + + /** + * Displays the menu options. + */ + private void displayMenu() { + System.out.println("-----------------MAIN MENU--------------"); + System.out.println("1. Read number pf lockers (integer value)"); + System.out.println("2. Run algorithm and display output"); + System.out.println("3. Exit program"); + System.out.println(); + } + + /** + * Runs the lockers algorithm and begins opening and closing the respective doors. + * After every toggle, the comparison operated is incremented as that is the basic operation. + */ + public void performAlgorithm() { + if (lockers == null || lockers.length == 0) { // Prevents code from being run on a null array. + return; + } + + comparisons = 0; + // Runs the algorithm n times through the entire list. + for (int base = 1; base <= lockers.length; base++) { + // Controls which lockers to flip. Goes from the base index to n, incremented by base. + for (int toggle = base-1; toggle < lockers.length; toggle=toggle+base) { + // Flips the locker door. + lockers[toggle].toggle(); // Basic Operation + comparisons++; + } + } + } +} + + +// Made my locker list easier to follow by toggling. +class Locker { + public boolean isOpen; + + Locker() { // Sets all new lockers to false. + isOpen = false; + } + + // Allowed for simpler switching. + public void toggle() { + isOpen = !isOpen; + } +} \ No newline at end of file diff --git a/src/LockerDoors.java b/src/LockerDoors.java deleted file mode 100644 index 2fb4c36..0000000 --- a/src/LockerDoors.java +++ /dev/null @@ -1,50 +0,0 @@ -// Name: Jonathan Turner -// Class: CS 4306/01 -// Term: Spring 2024 -// Instructor: Dr. Haddad -// Assignment: 1 -// IDE Name: IntelliJ -/* -Algorithm Design Block - Algorithm title: Find and print the smallest number in a list of numbers - Logical steps: - Step 1: Declare a variable to hold the smallest number. - Step 2: Set the smallest number variable to the first number in the list. - Step 2: Set a loop to check for a smaller number in the remainder of the list. - Update the smallest number variable if a smaller value is found. - Step 4: Print out the smallest number. - Pseudocode syntax: - Algorithm: Find and print smallest number in a list of numbers - Input: Non-empty List (L) of numbers - Output: Smallest number in list L - Begin - Smallest <- L[1]; - for i <- 2 to L.length do - if (L[i] < Smallest) - Smallest <- L[i]; - End Loop - Print out Smallest; - End; - ******************************************/ - - - -public class Main { - - - -} - - - -class Locker { - public boolean isOpen; - - Locker() { - isOpen = false; - } - - public void toggle() { - isOpen = !isOpen; - } -} \ No newline at end of file