diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3244509 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +target +.settings +.project +.classpath \ No newline at end of file diff --git a/feedback.txt b/feedback.txt index 8234592..23fe080 100644 --- a/feedback.txt +++ b/feedback.txt @@ -1,9 +1,17 @@ Your team (name of each individual participating): -How many JUnits were you able to get to pass? +Mike Razzakov + +How many JUnits were you able to get to pass? +All of them: 10/10 Document and describe any enhancements included to help the judges properly grade your submission. - Step 1: - Step 2: + Step 1: JavaDocs Added + Step 2: Created Method filterListBySearch to filter list of data by any given column. Used it to simplfy code / not repeat myself. + Step 3: Reused previously completed methods throughout the code. -Feedback for the coding competition? Things you would like to see in future events? \ No newline at end of file +Feedback for the coding competition? + Difficulty was great, wish it was more than 1 challenge, like the 2013 version. + +Things you would like to see in future events? + More variety of challenges put together like 2013 version. \ No newline at end of file diff --git a/src/main/java/codingcompetition2019/CodingCompCSVUtil.java b/src/main/java/codingcompetition2019/CodingCompCSVUtil.java index 74f3074..b3a5f20 100644 --- a/src/main/java/codingcompetition2019/CodingCompCSVUtil.java +++ b/src/main/java/codingcompetition2019/CodingCompCSVUtil.java @@ -1,42 +1,159 @@ package codingcompetition2019; +import java.io.BufferedReader; +import java.io.FileReader; import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; import java.util.List; + public class CodingCompCSVUtil { + + /** + * Reads CSV File and Parses by Country + * @param fileName CSV path + * @param countryName Name of Country + * @return List of Data for Specific Country + * @throws IOException Opening File Exception + */ public List> readCSVFileByCountry(String fileName, String countryName) throws IOException { - // TODO implement this method - return null; + + List> records = readCSVFileWithHeaders(fileName); + List> countryRecords = new ArrayList>(); + + for(List record : records) { + if(record.get(0).equals(countryName)) + countryRecords.add(record); + } + return countryRecords; } + /** + * Reads CSV File with the Headers + * @param fileName CSV path + * @return List of Data from the CSV File + * @throws IOException Opening File Exception + */ public List> readCSVFileWithHeaders(String fileName) throws IOException { - // TODO implement this method - return null; + + List> records = new ArrayList>(); + + try (BufferedReader br = new BufferedReader(new FileReader(fileName))) { + String line; + while ((line = br.readLine()) != null) { + String[] values = line.split(","); + records.add(Arrays.asList(values)); + } + } catch(Exception e) { + e.printStackTrace(); + } + return records; } + /** + * Reads CSV File without the Headers + * @param fileName CSV path + * @return List of Data from the CSV File + * @throws IOException Opening File Exception + */ public List> readCSVFileWithoutHeaders(String fileName) throws IOException { // TODO implement this method - return null; + List> records = readCSVFileWithHeaders(fileName); + records.remove(0); + return records; + } + /** + * Reads a list or records and finds the record with the most disasters + * @param records List of Records + * @return DisasterDescription Object which is the category, year, and the number of incidents for the disaster + */ public DisasterDescription getMostImpactfulYear(List> records) { // TODO implement this method - return null; + int maxDisasters = 0; + DisasterDescription disaster = new DisasterDescription(); + + for(List record : records) { + int disasterCount = Integer.parseInt(record.get(3)); + + if(disasterCount > maxDisasters) { + maxDisasters = disasterCount; + disaster.setYear(record.get(2)); + disaster.setCategory(record.get(0)); + disaster.setReportedIncidentsNum(disasterCount); + } + } + return disaster; } + /** + * Reads a list or records that match the category and finds the record year with the most disasters + * @param records List of Records + * @param category The type of disaster (earthquake, flood, ...) + * @return DisasterDescription Object which is the category, year, and the number of incidents for the disaster + */ public DisasterDescription getMostImpactfulYearByCategory(String category, List> records) { - // TODO implement this method - return null; + + return getMostImpactfulYear(filterListBySearch(0,category, records)); + } + + /** + * Filters the Lists by searching the rows; Can search rows by any column. + * @param column Column number to search by + * @param columnSearch Search term that you will filter the results by + * @param records List of Records that you want filtered + * @return A list of filtered records + */ + public List> filterListBySearch(int column, String columnSearch, List> records) { + List> newRecords = new ArrayList>(); + + for(List record : records) { + if(record.get(column).equals(columnSearch)){ + newRecords.add(record); + } + } + return newRecords; } + /** + * Filters the List by a specific year and looks for the greatest number of disasters + * @param records List of Records + * @param year Specific year to search for + * @return DisasterDescription Object which is the category, year, and the number of incidents for the disaster + */ public DisasterDescription getMostImpactfulDisasterByYear(String year, List> records) { - // TODO implement this method - return null; + List> catRecords = new ArrayList>(); + + for(List record : records) { + if(record.get(2).equals(year) && !(record.get(0).equals("All natural disasters"))){ //must ignore "All Natural Disasters" since it is the total + catRecords.add(record); + } + } + return getMostImpactfulYear(catRecords); } + /** + * Filters the List by a specific category and gets the sum of all incidents in that category + * @param records List of Records + * @param category Specific category to search for + * @return DisasterDescription Object which is the category and the number of incidents total + */ public DisasterDescription getTotalReportedIncidentsByCategory(String category, List> records) { // TODO implement this method - return null; + List> newRecords = new ArrayList>(); + int totalIncidentCount = 0; + + newRecords = filterListBySearch(0, category, records); + + for(List record : newRecords) { + int incidentCount = Integer.parseInt(record.get(3)); + + totalIncidentCount += incidentCount; + } + DisasterDescription totalDisaster = new DisasterDescription(category, totalIncidentCount); + return totalDisaster; } /** @@ -46,13 +163,52 @@ public DisasterDescription getTotalReportedIncidentsByCategory(String category, * + A min value can be provided, without providing a max value (which then has to be -1 like indicated above). * + If a max value is provided, then a max value is also needed. */ + + /** + * Counts the number of Years that have the disaster amount between the min and the max + * @param records List of Records + * @param min Minimum number of incidents to look for in the list + * @param max Maximum number of incidents to look for in the list; if -1, there is no maximum value + * @return the sum of the years with disasters between the min and the max values + */ public int countImpactfulYearsWithReportedIncidentsWithinRange(List> records, int min, int max) { // TODO implement this method - return -1; + + int countYear = 0; + + for(List record : records) { + int disasterCount = Integer.parseInt(record.get(3)); + if(disasterCount >= min && ((max==-1)?true:disasterCount <= max)) { + countYear++; + } + } + return countYear; } + /** + * Counts the number of incidents total in the records + * @param records List of Records + * @return the sum of total incidents + */ + public int getTotalIncidents(List> records) { + int total = 0; + + for(List record : records) { + int incidentCount = Integer.parseInt(record.get(3)); + total += incidentCount; + } + return total; + } + + /** + * Compares 2 records and sees if the incident count of the first list of records is larger than the second + * @param records List of Records + * @return true if incident count of records1 is larger than 2, false if incident count of records1 is smaller than 2 + */ public boolean firstRecordsHaveMoreReportedIndicents(List> records1, List> records2) { - // TODO implement this method + + if(getTotalIncidents(records1) > getTotalIncidents(records2)) + return true; return false; } } diff --git a/src/main/java/codingcompetition2019/DisasterDescription.java b/src/main/java/codingcompetition2019/DisasterDescription.java index 662626b..d5c6429 100644 --- a/src/main/java/codingcompetition2019/DisasterDescription.java +++ b/src/main/java/codingcompetition2019/DisasterDescription.java @@ -2,4 +2,44 @@ public class DisasterDescription { // TODO finish this class + String year; + String category; + int reportedIncidentsNum; + + public DisasterDescription() { + + } + + public DisasterDescription(String category, int reportedIncidentsNum) { + super(); + this.category = category; + this.reportedIncidentsNum = reportedIncidentsNum; + } + + public DisasterDescription(String category, int reportedIncidentsNum, String year) { + super(); + this.year = year; + } + + public String getYear() { + return year; + } + public void setYear(String year) { + this.year = year; + } + public String getCategory() { + return category; + } + public void setCategory(String category) { + this.category = category; + } + public int getReportedIncidentsNum() { + return reportedIncidentsNum; + } + public void setReportedIncidentsNum(int reportedIncidentsNum) { + this.reportedIncidentsNum = reportedIncidentsNum; + } + + + }