Merge branch 'fixMediumPizzaSlicing' into refactoring

LyashenkoGS · LyashenkoGS · commit 98f1987fa6b8 · 2017-02-12T18:46:55.000+02:00
diff --git a/.gitignore b/.gitignore
@@ -7,6 +7,7 @@
 target
 #ignore the archived source code and output files
 /outputDataSet/*
+*.log
 *.zip
 /.classpath
 .settings/
diff --git a/README.md b/README.md
@@ -5,7 +5,7 @@ hash tags: #hashcode #2017 #googleHashCode
 [![Build Status](https://travis-ci.org/LyashenkoGS/GoogleHashCode2017.svg?branch=master)](https://travis-ci.org/LyashenkoGS/GoogleHashCode2017)
 
 ##Pizza
-Practice problem for the Google HashCode 2017. Current version works correctly for example input only.
+Practice problem for the Google HashCode 2017.
 
 * original assignment - [Task.pdf](./documentation/TaskDescription.pdf)
 * [input data sets](./inputDataSets)
@@ -30,6 +30,8 @@ To zip the source code execute :
 
     ./zipSourceCode.sh
     
+    
+## Deprecated
 To automate interaction with online submission can be used [SeleniumIDE](https://addons.mozilla.org/en-US/firefox/addon/selenium-ide/)
  with a firefox browser.
 * login  to the [submission page](https://hashcodejudge.withgoogle.com/#/rounds/6553823069863936/submissions/)
diff --git a/hs_err_pid9247.log b/hs_err_pid9247.log
diff --git a/outputDataSet/example.txt b/outputDataSet/example.txt
@@ -0,0 +1,4 @@
+3
+1 2 2 2
+1 3 1 4
+1 0 1 1
diff --git a/pizzaSlicing.log b/pizzaSlicing.log
diff --git a/src/main/java/com/google/hashcode/App.java b/src/main/java/com/google/hashcode/App.java
@@ -3,7 +3,6 @@
 import com.google.hashcode.entity.Pizza;
 import com.google.hashcode.entity.Slice;
 import com.google.hashcode.entity.Step;
-import com.google.hashcode.utils.SlicingMethods;
 import com.google.hashcode.utils.IoUtils;
 import com.google.hashcode.utils.Profiler;
 import org.slf4j.Logger;
@@ -15,39 +14,53 @@
 import java.util.List;
 import java.util.Map;
 
-import static com.google.hashcode.utils.FilesPaths.*;
+import static com.google.hashcode.utils.FilesPaths.BIG_INPUT_FILE_PATH;
+import static com.google.hashcode.utils.FilesPaths.OUTPUT_DATA_SET_BIG_TXT;
+import static com.google.hashcode.utils.SlicingMethods.*;
 
 
 public class App {
     private static final Logger LOGGER = LoggerFactory.getLogger(App.class);
 
     public static void main(String[] args) throws IOException {
-        slicePizza(EXAMPLE_INPUT_FILE_PATH, OUTPUT_DATA_SET_EXAMPLE_TXT);
-        slicePizza(SMALL_INPUT_FILE_PATH, OUTPUT_DATA_SET_SMALL_TXT);
-        slicePizza(MEDIUM_INPUT_FILE_PATH, OUTPUT_DATA_SET_MEDIUM_TXT);
-        //TODO troubles to input big files, possible exciting String max size
-        //slicePizza(BIG_INPUT_FILE_PATH, OUTPUT_DATA_SET_BIG_TXT);
+        //slicePizza(EXAMPLE_INPUT_FILE_PATH, OUTPUT_DATA_SET_EXAMPLE_TXT);
+        //slicePizza(SMALL_INPUT_FILE_PATH, OUTPUT_DATA_SET_SMALL_TXT);
+        //slicePizza(MEDIUM_INPUT_FILE_PATH, OUTPUT_DATA_SET_MEDIUM_TXT);
+        slicePizza(BIG_INPUT_FILE_PATH, OUTPUT_DATA_SET_BIG_TXT);
     }
 
+    /**
+     * Performs a pizza slicing
+     *
+     * @param inputFile  given input pizza file
+     * @param outputFile a file slicing results
+     * @throws IOException cant parse a pizza file
+     */
     public static void slicePizza(String inputFile, String outputFile) throws IOException {
         Profiler profiler = new Profiler();
         List<Slice> startPositions;
         List<Slice> output = new ArrayList<>();
         Pizza pizza = new Pizza(new File(inputFile), IoUtils.parsePizza(inputFile), IoUtils.parseSliceInstructions(inputFile));
         //get start positions
-        startPositions = SlicingMethods.cutAllStartPositions(pizza);
+        startPositions = cutAllStartPositions(pizza);
         //get All steps
-        Map<Slice, List<Step>> availableSteps = SlicingMethods.getAvailableSteps(pizza, startPositions, output);
+        Map<Slice, List<Step>> availableSteps = getAvailableSteps(pizza, startPositions, output);
         while (!availableSteps.values().stream().allMatch(List::isEmpty)) {
-            Step step = SlicingMethods.selectStep(availableSteps);
-            SlicingMethods.performStep(pizza, step, startPositions, output);
-            //TODO available steps should include merging slices to each other
-            availableSteps = SlicingMethods.getAvailableSteps(pizza, startPositions, output);
+            Step step = selectStep(availableSteps);
+            performStep(pizza, step, startPositions, output);
+            availableSteps = getAvailableSteps(pizza, startPositions, output);
             LOGGER.info("OUTPUT AFTER A STEP: "
                     + "\n " + output);
+            LOGGER.info("start positions cells number: " + startPositions.stream()
+                    .map(slice -> slice.cells.size())
+                    .reduce(0, (integer, integer2) -> integer + integer2)
+            );
         }
         IoUtils.writeToFile(outputFile, IoUtils.parseSlices(output));
         LOGGER.info("FINISHED for " + inputFile + "!!!!!");
+        LOGGER.info("sliced cells number: " + output.stream()
+                .map(slice -> slice.cells.size())
+                .reduce(0, (integer, integer2) -> integer + integer2));
         LOGGER.info(profiler.measure(inputFile + " execution time: "));
     }
 
diff --git a/src/main/java/com/google/hashcode/entity/Pizza.java b/src/main/java/com/google/hashcode/entity/Pizza.java
@@ -13,8 +13,8 @@
 public class Pizza {
 
     private final File input;
-    private final List<Cell> cells;
     private final SliceInstruction sliceInstruction;
+    private List<Cell> cells;
 
     public Pizza(File input, List<Cell> cells, SliceInstruction sliceInstruction) {
         this.input = input;
@@ -30,6 +30,10 @@ public List<Cell> getCells() {
         return cells;
     }
 
+    public void setCells(List<Cell> cells) {
+        this.cells = cells;
+    }
+
     /**
      * Coordinates are like in a 2D array
      *
diff --git a/src/main/java/com/google/hashcode/entity/Slice.java b/src/main/java/com/google/hashcode/entity/Slice.java
@@ -116,7 +116,7 @@ public boolean isValid(Pizza pizza) {
         boolean isPassedSliceInstructions = this.cells.size() <= pizza.getSliceInstruction().getMaxNumberOfCellsPerSlice()
                 && tomatoesNumber >= pizza.getSliceInstruction().getMinNumberOfIngredientPerSlice()
                 && mushroomsNumber >= pizza.getSliceInstruction().getMinNumberOfIngredientPerSlice();
-        LOGGER.info("\n" + pizza.getSliceInstruction() +
+        LOGGER.debug("\n" + pizza.getSliceInstruction() +
                 "\nSlice :" + this +
                 "\npassed validation: " + isPassedSliceInstructions);
         return isPassedSliceInstructions;
@@ -132,7 +132,7 @@ public Step generateStepAbove(Pizza pizza) {
             if (cell.isPresent()) {
                 delta.cells.add(cell.get());
             } else {
-                LOGGER.info("cant perform step left !");
+                LOGGER.debug("cant perform step left !");
                 return null;
             }
         }
@@ -142,7 +142,7 @@ public Step generateStepAbove(Pizza pizza) {
         if (step.isValid(pizza)) {
             return step;
         } else {
-            LOGGER.info("step is invalid !");
+            LOGGER.debug("step is invalid !");
             return null;
         }
     }
@@ -155,7 +155,7 @@ public Step generateStepBelow(Pizza pizza) {
             if (cell.isPresent()) {
                 delta.cells.add(cell.get());
             } else {
-                LOGGER.info("cant perform step left !");
+                LOGGER.debug("cant perform step left !");
                 return null;
             }
         }
@@ -165,7 +165,7 @@ public Step generateStepBelow(Pizza pizza) {
         if (step.isValid(pizza)) {
             return step;
         } else {
-            LOGGER.info("step is invalid !");
+            LOGGER.debug("step is invalid !");
             return null;
         }
     }
@@ -178,7 +178,7 @@ public Step generateStepLeft(Pizza pizza) {
             if (cell.isPresent()) {
                 delta.cells.add(cell.get());
             } else {
-                LOGGER.info("cant perform step left !");
+                LOGGER.debug("cant perform step left !");
                 return null;
             }
         }
@@ -188,7 +188,7 @@ public Step generateStepLeft(Pizza pizza) {
         if (step.isValid(pizza)) {
             return step;
         } else {
-            LOGGER.info("step is invalid !");
+            LOGGER.debug("step is invalid !");
             return null;
         }
     }
@@ -201,7 +201,7 @@ public Step generateStepRight(Pizza pizza) {
             if (cell.isPresent()) {
                 delta.cells.add(cell.get());
             } else {
-                LOGGER.info("cant perform step right !");
+                LOGGER.debug("cant perform step right !");
                 return null;
             }
         }
@@ -211,7 +211,7 @@ public Step generateStepRight(Pizza pizza) {
         if (step.isValid(pizza)) {
             return step;
         } else {
-            LOGGER.info("step is invalid !");
+            LOGGER.debug("step is invalid !");
             return null;
         }
     }
diff --git a/src/main/java/com/google/hashcode/entity/Step.java b/src/main/java/com/google/hashcode/entity/Step.java
@@ -22,7 +22,8 @@ public Step(Slice startPosition, Slice delta) {
     public boolean isValid(Pizza pizza) {
         Slice slice = new Slice(new ArrayList<>(startPosition.cells));
         slice.cells.addAll(delta.cells);
-        return slice.isValid(pizza);
+        return slice.isValid(pizza) ||
+                slice.cells.size() < pizza.getSliceInstruction().getMaxNumberOfCellsPerSlice();
     }
 
     public int size() {
diff --git a/src/main/java/com/google/hashcode/utils/IoUtils.java b/src/main/java/com/google/hashcode/utils/IoUtils.java
@@ -40,12 +40,9 @@ public static List<Cell> parsePizza(String file) throws IOException {
             List<Cell> cells = new ArrayList<>();
             int row = 0;
             String fileLine;
-            int counter = 0;
             while ((fileLine = br.readLine()) != null) {
                 for (int column = 0; column < fileLine.length(); column++) {
                     Character literal = fileLine.charAt(column);
-                    counter++;
-                    System.out.println("letter " + literal + " counter = " + counter);
                     if (literal.toString().equals(Ingredient.TOMATO.toString())) {
                         cells.add(new Cell(row, column, Ingredient.TOMATO));
                     } else if (literal.toString().equals(Ingredient.MUSHROOM.toString())) {
diff --git a/src/main/java/com/google/hashcode/utils/SlicingMethods.java b/src/main/java/com/google/hashcode/utils/SlicingMethods.java
@@ -29,7 +29,16 @@ private SlicingMethods() {
      */
     public static Map<Slice, List<Step>> getAvailableSteps(Pizza pizza, List<Slice> startPositions, List<Slice> output) {
         Map<Slice, List<Step>> groupedByAStartPositionSteps = new HashMap<>();
-        Iterator iterator = startPositions.iterator();
+        Iterator iterator;
+        //optimization for big arrays
+        if (startPositions.size() > 1_000) {
+            List<Slice> startPositionsSubset = startPositions.subList(0, 20);
+            iterator = startPositionsSubset.iterator();
+        }
+        //iterate over all the start positions
+        else {
+            iterator = startPositions.iterator();
+        }
         while (iterator.hasNext()) {
             Slice startPosition = (Slice) iterator.next();
 
@@ -54,7 +63,7 @@ public static Map<Slice, List<Step>> getAvailableSteps(Pizza pizza, List<Slice>
                     output.add(startPosition);
                     iterator.remove();
                 } else {
-                    LOGGER.warn("A start position ISN'T valid as a slice -> " +
+                    LOGGER.debug("A start position ISN'T valid as a slice -> " +
                             "remove it from startPositions and add all it cells");
                     pizza.getCells().addAll(startPosition.cells);
                     iterator.remove();
@@ -63,7 +72,7 @@ public static Map<Slice, List<Step>> getAvailableSteps(Pizza pizza, List<Slice>
                 groupedByAStartPositionSteps.put(startPosition, steps);
             }
         }
-        LOGGER.info("available steps for" +
+        LOGGER.debug("available steps for" +
                 "\npizza: " + pizza
                 + "\nsteps: " + groupedByAStartPositionSteps);
         return groupedByAStartPositionSteps;
@@ -80,20 +89,22 @@ public static Map<Slice, List<Step>> getAvailableSteps(Pizza pizza, List<Slice>
     public static void performStep(Pizza pizza, Step step, List<Slice> startPositions, List<Slice> output) {
         //1. Pick ups a steps list with minimal total cells number
         LOGGER.debug("STEP TO PERFORM " + step);
-        //2. Cut all the step delta cells from a pizza
+        //2. Cut all the step delta cells from pizza
         LOGGER.debug("pizza before step: " + pizza
                 + "\ndelta to remove from the pizza: " + step.delta);
         pizza.getCells().removeAll(step.delta.cells);
-        //3. remove previous version start position from startPositions
+        //3. remove step start position from total start positions
         startPositions.remove(step.startPosition);
         List<Cell> returnedList = step.startPosition.cells;
         returnedList.addAll(step.delta.cells);
         Slice finalSlice = new Slice(returnedList);
         LOGGER.debug("PIZZA AFTER STEP:" + pizza);
-        //3. Add the step cells to an output slice
-        if (finalSlice.cells.size() == pizza.getSliceInstruction().getMaxNumberOfCellsPerSlice()) {
+        //3. Add the step cells to an output slice if it's valid
+        if (finalSlice.isValid(pizza)) {
             output.add(finalSlice);
-        } else {
+        }
+        //4. add start position + delta to start positions
+        else {
             startPositions.add(finalSlice);
         }
     }
@@ -107,9 +118,13 @@ public static void performStep(Pizza pizza, Step step, List<Slice> startPosition
     public static Step selectStep(Map<Slice, List<Step>> steps) {
         //TODO test and refactor this peace of shit properly !!
         List<Step> min = steps.values().stream()
-                .min(Comparator.comparingLong(value -> value.stream().map(step -> step.delta.cells.size()).count())).get();
+                .min(Comparator.comparingLong(value ->
+                        value.stream()
+                                .map(step -> step.delta.cells.size())
+                                .count()))
+                .get();
         if (!min.isEmpty()) {
-            LOGGER.info("steps list with minimal number of delta cells: " + min);
+            LOGGER.debug("steps list with minimal number of delta cells: " + min);
             return min.get(0);
         } else {
             Optional<List<Step>> optionalStep = steps.values().stream().filter(steps1 -> !steps1.isEmpty()).findFirst();
@@ -146,18 +161,12 @@ public static List<Slice> cutAllStartPositions(Pizza pizza) {
             startPositions = tomatoes.stream()
                     .map(Slice::new)
                     .collect(Collectors.toList());
-            List<Cell> cellsToRemove = startPositions.stream()
-                    .flatMap(slice -> slice.cells.stream())
-                    .collect(Collectors.toList());
-            pizza.getCells().removeAll(cellsToRemove);
+            pizza.setCells(mushrooms);
         } else {
             startPositions = mushrooms.stream()
                     .map(Slice::new)
                     .collect(Collectors.toList());
-            List<Cell> cellsToRemove = startPositions.stream()
-                    .flatMap(slice -> slice.cells.stream())
-                    .collect(Collectors.toList());
-            pizza.getCells().removeAll(cellsToRemove);
+            pizza.setCells(tomatoes);
         }
         LOGGER.debug("pizza with removed start positions:"
                 + "\n" + pizza);
diff --git a/src/main/resources/logback.xml b/src/main/resources/logback.xml
@@ -9,12 +9,24 @@
         </layout>
     </appender>
 
-    <root level="debug">
+    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
+        <file>./pizzaSlicing.log</file>
+        <append>false</append>
+        <encoder>
+            <pattern>
+                %d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="info">
         <appender-ref ref="STDOUT"/>
     </root>
 
-    <logger name="com.google" level="debug"
+    <logger name="com.google" level="info"
             additivity="false">
+        <appender-ref ref="FILE"/>
         <appender-ref ref="STDOUT"/>
     </logger>
+
 </configuration>
diff --git a/src/test/java/com/google/hashcode/utils/SlicingMethodsTest.java b/src/test/java/com/google/hashcode/utils/SlicingMethodsTest.java
@@ -17,7 +17,7 @@
 /**
  * @author Grigoriy Lyashenko (Grog).
  */
-public class DFSMethodsTest {
+public class SlicingMethodsTest {
 
     private Pizza pizza;
 
@@ -53,8 +53,6 @@ public void performStep() {
         List<Slice> output = new ArrayList<>();
         Map<Slice, List<Step>> availableSteps = SlicingMethods.getAvailableSteps(pizza, startPositions, output);
         SlicingMethods.performStep(pizza, SlicingMethods.selectStep(availableSteps), startPositions, output);
-        assertEquals(new Slice(Arrays.asList(new Cell(1, 2, Ingredient.MUSHROOM), new Cell(2, 2, Ingredient.TOMATO)))
-                , startPositions.get(2));
         assertEquals(11, pizza.getCells().size());
     }
 }

-Original file line number
+Diff line change
@@ @@ -0,0 +1,4 @@ @@
 +3
 +1 2 2 2
 +1 3 1 4
 +1 0 1 1
Original file line number	Diff line number	Diff line change
`@@ -116,7 +116,7 @@ public boolean isValid(Pizza pizza) {`
`116`	`116`	`boolean isPassedSliceInstructions = this.cells.size() <= pizza.getSliceInstruction().getMaxNumberOfCellsPerSlice()`
`117`	`117`	`&& tomatoesNumber >= pizza.getSliceInstruction().getMinNumberOfIngredientPerSlice()`
`118`	`118`	`&& mushroomsNumber >= pizza.getSliceInstruction().getMinNumberOfIngredientPerSlice();`
`119`		`- LOGGER.info("\n" + pizza.getSliceInstruction() +`
	`119`	`+ LOGGER.debug("\n" + pizza.getSliceInstruction() +`
`120`	`120`	`"\nSlice :" + this +`
`121`	`121`	`"\npassed validation: " + isPassedSliceInstructions);`
`122`	`122`	`return isPassedSliceInstructions;`
`@@ -132,7 +132,7 @@ public Step generateStepAbove(Pizza pizza) {`
`132`	`132`	`if (cell.isPresent()) {`
`133`	`133`	`delta.cells.add(cell.get());`
`134`	`134`	`} else {`
`135`		`- LOGGER.info("cant perform step left !");`
	`135`	`+ LOGGER.debug("cant perform step left !");`
`136`	`136`	`return null;`
`137`	`137`	`}`
`138`	`138`	`}`
`@@ -142,7 +142,7 @@ public Step generateStepAbove(Pizza pizza) {`
`142`	`142`	`if (step.isValid(pizza)) {`
`143`	`143`	`return step;`
`144`	`144`	`} else {`
`145`		`- LOGGER.info("step is invalid !");`
	`145`	`+ LOGGER.debug("step is invalid !");`
`146`	`146`	`return null;`
`147`	`147`	`}`
`148`	`148`	`}`
`@@ -155,7 +155,7 @@ public Step generateStepBelow(Pizza pizza) {`
`155`	`155`	`if (cell.isPresent()) {`
`156`	`156`	`delta.cells.add(cell.get());`
`157`	`157`	`} else {`
`158`		`- LOGGER.info("cant perform step left !");`
	`158`	`+ LOGGER.debug("cant perform step left !");`
`159`	`159`	`return null;`
`160`	`160`	`}`
`161`	`161`	`}`
`@@ -165,7 +165,7 @@ public Step generateStepBelow(Pizza pizza) {`
`165`	`165`	`if (step.isValid(pizza)) {`
`166`	`166`	`return step;`
`167`	`167`	`} else {`
`168`		`- LOGGER.info("step is invalid !");`
	`168`	`+ LOGGER.debug("step is invalid !");`
`169`	`169`	`return null;`
`170`	`170`	`}`
`171`	`171`	`}`
`@@ -178,7 +178,7 @@ public Step generateStepLeft(Pizza pizza) {`
`178`	`178`	`if (cell.isPresent()) {`
`179`	`179`	`delta.cells.add(cell.get());`
`180`	`180`	`} else {`
`181`		`- LOGGER.info("cant perform step left !");`
	`181`	`+ LOGGER.debug("cant perform step left !");`
`182`	`182`	`return null;`
`183`	`183`	`}`
`184`	`184`	`}`
`@@ -188,7 +188,7 @@ public Step generateStepLeft(Pizza pizza) {`
`188`	`188`	`if (step.isValid(pizza)) {`
`189`	`189`	`return step;`
`190`	`190`	`} else {`
`191`		`- LOGGER.info("step is invalid !");`
	`191`	`+ LOGGER.debug("step is invalid !");`
`192`	`192`	`return null;`
`193`	`193`	`}`
`194`	`194`	`}`
`@@ -201,7 +201,7 @@ public Step generateStepRight(Pizza pizza) {`
`201`	`201`	`if (cell.isPresent()) {`
`202`	`202`	`delta.cells.add(cell.get());`
`203`	`203`	`} else {`
`204`		`- LOGGER.info("cant perform step right !");`
	`204`	`+ LOGGER.debug("cant perform step right !");`
`205`	`205`	`return null;`
`206`	`206`	`}`
`207`	`207`	`}`
`@@ -211,7 +211,7 @@ public Step generateStepRight(Pizza pizza) {`
`211`	`211`	`if (step.isValid(pizza)) {`
`212`	`212`	`return step;`
`213`	`213`	`} else {`
`214`		`- LOGGER.info("step is invalid !");`
	`214`	`+ LOGGER.debug("step is invalid !");`
`215`	`215`	`return null;`
`216`	`216`	`}`
`217`	`217`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,8 @@ public Step(Slice startPosition, Slice delta) {`
`22`	`22`	`public boolean isValid(Pizza pizza) {`
`23`	`23`	`Slice slice = new Slice(new ArrayList<>(startPosition.cells));`
`24`	`24`	`slice.cells.addAll(delta.cells);`
`25`		`- return slice.isValid(pizza);`
	`25`	`+ return slice.isValid(pizza) \|\|`
	`26`	`+ slice.cells.size() < pizza.getSliceInstruction().getMaxNumberOfCellsPerSlice();`
`26`	`27`	`}`
`27`	`28`
`28`	`29`	`public int size() {`