ProjectEuler/ProjectEulerJava
1
0
Fork 0
mirror of https://bitbucket.org/Mattrixwv/projecteulerjava.git synced 2025-12-06 17:13:58 -05:00
Code Issues Packages Projects Releases Wiki Activity

Added some functions to reduce the amount of copied code

Browse Source
This commit is contained in:
Mattrixwv
2020-07-10 00:53:19 -04:00
parent 44cbc2970c
commit 941372e90c
1 changed files with 81 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

133
src/main/java/mattrixwv/ProjectEuler/Benchmark.java
View File

@@ -1,5 +1,27 @@
//ProjectEuler/ProjectEulerJava/src/man/java/mattrixwv/ProjectEuler/Benchmark.java
//Matthew Ellison
// Created: 07-08-20
//Modified: 07-09-20
//This is the driver function for the Java version of the ProjectEuler project
/*
Copyright (C) 2020 Matthew Ellison
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package mattrixwv.ProjectEuler;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
@@ -7,10 +29,12 @@ import java.util.Scanner;
import mattrixwv.Stopwatch;
import mattrixwv.ProjectEuler.Problems.Problem;
public class Benchmark{
private static final Scanner input = new Scanner(System.in);
private static enum BenchmarkOptions{runSpecific, runAllShort, runAll, exit, size};
private static final ArrayList<Integer> tooLong = new ArrayList<Integer>(Arrays.asList(15));
private static final ArrayList<Integer> tooLong = new ArrayList<Integer>(Arrays.asList(15, 23, 24, 27));
//The driver function for the benchmark selection
public static void benchmarkMenu(){
BenchmarkOptions selection = BenchmarkOptions.size;
@@ -25,6 +49,7 @@ public class Benchmark{
case size : break;
}
}
//Print the benchmark menu
private static void printMenu(){
System.out.println("1. Run a specific problem");
System.out.println("2. Run all problems that have a reasonably short run time");
@@ -32,15 +57,17 @@ public class Benchmark{
System.out.println("4. Exit the menu");
System.out.println();
}
//Returns a valid menu option
private static BenchmarkOptions getMenuSelection(){
int selection = input.nextInt();
while(!isValidMenu(selection)){
System.out.println("That is an invalid option!Press Enter to continue");
System.out.println("That is an invalid option!\nPress Enter to continue");
printMenu();
selection = input.nextInt();
}
return getSelection(selection);
}
//Determines if a value is a valid menu option. Helper for getBechmarkMenuSelection
private static boolean isValidMenu(int selection){
//Ordinal + 1 because enum starts at 0
if((selection > 0) && (selection < (BenchmarkOptions.size.ordinal() + 1))){
@@ -50,6 +77,7 @@ public class Benchmark{
return false;
}
}
//A helper function for getMenuSelection that turns an integer to a BenchmarkOptions
private static BenchmarkOptions getSelection(Integer selection){
BenchmarkOptions sel = null;
@@ -62,92 +90,69 @@ public class Benchmark{
}
return sel;
}
//Determines which problem user wants to run and runs it
private static void runSpecific(){
double totalTime = 0;
//Ask which problem the user wants to run
int problemNumber = ProblemSelection.getProblemNumber();
//Ask how many times to run the problem
int timesToRun = getNumberOfTimesToRun();
//Get the problem
//Get the problem and print its description
Problem problem = ProblemSelection.getProblem(problemNumber);
//Run the problem the specific number of times
System.out.println(problemNumber + ". " + problem.getDescription());
System.out.print("Solving");
for(int cnt = 0;cnt < timesToRun;++cnt){
//Reset the data so you are actually counting the run time a second time
System.out.print('.');
//Solve the problem
problem.solve();
//Get the time data
totalTime += problem.getTimer().getNano();
}
//Calculate the average run time
totalTime /= timesToRun;
String timeResults = Stopwatch.getStr(totalTime);
//Run the problem the specific number of times
double totalTime = runProblem(problem, timesToRun);
//Print the results
System.out.println("\n" + problem.getResult());
System.out.println("It took an average of " + timeResults + " to run this problem through " + timesToRun + " iterations\n\n");
System.out.println(getBenchmarkResults(problem, totalTime, timesToRun));
}
//Runs all problems except a few that are specified because of run length
private static void runAllShort(){
//Ask how many times to run the problem
int timesToRun = getNumberOfTimesToRun();
//Run through all valid problem numbers, skipping a few that are in the tooLong list
for(int cnt = 1;cnt < ProblemSelection.PROBLEM_NUMBERS.size();++cnt){
int problemNumber = ProblemSelection.PROBLEM_NUMBERS.get(cnt);
double totalTime = 0;
//If the problem number is contained in the list of problems that take too long skip it
if(tooLong.contains(problemNumber)){
continue;
}
//Get the problem and print its description
Problem problem = ProblemSelection.getProblem(problemNumber);
//Run each problem the specified number of times
System.out.println(problemNumber + ". " + problem.getDescription());
System.out.print("Solving");
for(int cnt2 = 0;cnt2 < timesToRun;++cnt2){
//Get the problem
problem = ProblemSelection.getProblem(problemNumber);
System.out.print('.');
//Solve the problem
problem.solve();
//Get the time data
totalTime += problem.getTimer().getNano();
}
//Calculate the averate run time of the problem
totalTime /= timesToRun;
String timeResults = Stopwatch.getStr(totalTime);
//Run each problem the specified number of times
double totalTime = runProblem(problem, timesToRun);
//Print the results
System.out.println("\n\n" + problem.getResult());
System.out.println("It took an average of " + timeResults + " to run this problem through " + timesToRun + " iterations\n\n");
System.out.println(getBenchmarkResults(problem, totalTime, timesToRun));
}
}
//Runs all problems
private static void runAll(){
//Ask how many times to run the problem
int timesToRun = getNumberOfTimesToRun();
//Run through all valid problem numbers, skipping a few that are in the tooLong list
for(int cnt = 1;cnt < ProblemSelection.PROBLEM_NUMBERS.size();++cnt){
int problemNumber = ProblemSelection.PROBLEM_NUMBERS.get(cnt);
double totalTime = 0;
//Get the problem
Problem problem = ProblemSelection.getProblem(problemNumber);
//Run each problem the specified number of times
System.out.println(problemNumber + ". " + problem.getDescription());
System.out.print("Solving");
for(int cnt2 = 0;cnt2 < timesToRun;++cnt2){
//Get the problem
problem = ProblemSelection.getProblem(problemNumber);
System.out.print('.');
//Solve the problem
problem.solve();
//Get the time data
totalTime += problem.getTimer().getNano();
}
//Calculate the averate run time of the problem
totalTime /= timesToRun;
String timeResults = Stopwatch.getStr(totalTime);
double totalTime = runProblem(problem, timesToRun);
//Print the results
System.out.println("\n\n" + problem.getResult());
System.out.println("It took an average of " + timeResults + " to run this problem through " + timesToRun + " iterations\n\n");
System.out.println(getBenchmarkResults(problem, totalTime, timesToRun));
}
}
//Asks how many times a problem is supposed to run and returns the value
private static int getNumberOfTimesToRun(){
int numOfTimesToRun = 1;
System.out.print("How many times do you want to run this problem? ");
@@ -159,4 +164,28 @@ public class Benchmark{
}
return numOfTimesToRun;
}
//Runs the problem the given number of times
private static double runProblem(Problem problem, int timesToRun){
double totalTime = 0;
System.out.print("Solving");
for(int cnt = 0;cnt < timesToRun;++cnt){
//Reset the data so you are actually counting the run time a second time
System.out.print('.');
//Solve the problem
problem.solve();
//Get the time data
totalTime += problem.getTimer().getNano();
}
return totalTime;
}
//Prints the benchmark results of a problem
private static String getBenchmarkResults(Problem problem, double totalTime, int timesRun){
//Calculate the averate run time of the problem
totalTime /= timesRun;
String timeResults = Stopwatch.getStr(totalTime);
//Tally the results
String results = "\n\n" + problem.getResult() + "\nIt took an average of " + timeResults + " to run this problem through " + timesRun + " iterations\n\n";
return results;
}
}