Turner/CS4306-Algorithm_Analysis
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactered into subfolders.

Browse Source
This commit is contained in:
Jonathan Turner 2024-01-24 01:04:02 -05:00
parent 2879dd093c
commit 6b620cf0a1
4 changed files with 443 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/AnagramsCheck.java
View File

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

224
src/Assignment1/AnagramsCheck.java Normal file
View File

@ -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;
}
}

219
src/Assignment1/LockerDoors.java Normal file
View File

@ -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;
}
}

50
src/LockerDoors.java
View File

@ -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;
}
}