DFS_performStep. Implement perform step, fix Pizza toString, fix cutStartPositions

Author: LyashenkoGS

src/main/java/com/google/hashcode/entity/Pizza.java

@@ -37,13 +37,8 @@ public List<Cell> getCells() {
      * @param x - column number,0..max column number
      * @return a pizza cell with specified coordinated
      */
-    public Cell getCell(int y, int x) {
-        final Optional<Cell> cellByCoordinates = cells.stream().filter(cell -> cell.x == x && cell.y == y).findFirst();
-        if (cellByCoordinates.isPresent()) {
-            return cellByCoordinates.get();
-        } else throw new IllegalArgumentException("No cell with "
-                + "\n y: " + y
-                + "\nx: " + x);
+    public Optional<Cell> getCell(int y, int x) {
+        return cells.stream().filter(cell -> cell.x == x && cell.y == y).findFirst();
     }
 
     public SliceInstruction getSliceInstruction() {
@@ -81,7 +76,11 @@ private String outputCellsArray() {
             //output rows coordinates
             stringBuilder.append(row).append(" ");
             for (int column = 0; column < columnsCount + 1; column++) {
-                stringBuilder.append(this.getCell(row, column).toString()).append(" ");
+                if (this.getCell(row, column).isPresent()) {
+                    stringBuilder.append(this.getCell(row, column).get().toString()).append(" ");
+                } else {
+                    stringBuilder.append(" ").append(" ");
+                }
             }
             stringBuilder.append("\n");
         }

src/main/java/com/google/hashcode/entity/Slice.java

@@ -13,23 +13,20 @@
  */
 public class Slice {
     private static final Logger LOGGER = LoggerFactory.getLogger(Slice.class);
+
     public List<Cell> cells = new ArrayList<>();
 
     public Slice() {
     }
 
-    public Slice(Cell cell) {
-        this.cells = Collections.singletonList(cell);
+    public Slice(Cell... cell) {
+        this.cells = Arrays.asList(cell);
     }
 
     public Slice(List<Cell> cells) {
         this.cells = cells;
     }
 
-    public List<Cell> getCells() {
-        return cells;
-    }
-
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;

src/main/java/com/google/hashcode/utils/DFSMethods.java

@@ -4,7 +4,10 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 
 public abstract class DFSMethods {
@@ -13,44 +16,6 @@ public abstract class DFSMethods {
     private DFSMethods() {
     }
 
-    /**
-     * Step as an entity is an amount of a pizza cells, that can be added to a slice of a pizza or a pizza cell.<br>
-     * Step as an action is a process of:<br>
-     * <p>
-     * * adding cells to a start cell or a start slice<br>
-     * * validate generated slice according to the pizza slicing instructions<br>
-     * * if validation passed ->cutting the start cell with added cells from the pizza
-     *
-     * @param pizza (mutable) a pizza to perform step on
-     * @param slice start position for a step
-     * @return cutted slice from the pizza
-     */
-    public static Optional<Slice> rightStep(Pizza pizza, Slice slice) {
-        List<Cell> slicesRightBorder = slice.cells.stream()
-                .filter(cell -> (cell.x == slice.maxX()) && (cell.y >= slice.minY()) && (cell.y <= slice.maxY()))
-                .collect(Collectors.toList());
-        //each cell should have a cell right side of it in the pizza
-        try {
-            Slice step = new Slice(slicesRightBorder.stream()
-                    .map(slicesRightBorderCell -> pizza.getCell(slicesRightBorderCell.y, slicesRightBorderCell.x + 1))
-                    .collect(Collectors.toList()));
-            //check is step is valid
-            Slice sliceAndStep = new Slice(new ArrayList(slice.cells));
-            sliceAndStep.cells.addAll(step.cells);
-            if (!slice.cells.isEmpty() && sliceAndStep.isValid(pizza)) {
-                //remove the slice and step from the pizza
-                pizza.getCells().removeAll(sliceAndStep.cells);
-                return Optional.of(sliceAndStep);
-            } else {
-                return Optional.empty();
-            }
-        } catch (IllegalArgumentException e) {
-            //if can't add at least one neccessary cell - > return an empty step
-            LOGGER.info("Can't perform a step right !");
-            return Optional.empty();
-        }
-    }
-
     /**
      * For each slice find all available steps. We DON'T change the pizza on this stage
      *
@@ -87,14 +52,24 @@ public static Map<Slice, List<Step>> getAvailableSteps(Pizza pizza, List<Slice>
      * @param steps available steps
      * @return formed slice that includes an original slice and delta from a step
      */
-    public static List<Step> performStep(Pizza pizza, Map<Slice, List<Step>> steps) {
+    public static Slice performStep(Pizza pizza, Map<Slice, List<Step>> steps) {
         //1. Pick ups a steps list with minimal total cells number
-        final Optional<List<Step>> minStep = steps.values().stream().min((o1, o2) -> new StepsComparator().compare(o1, o2));
-        return minStep.get();
+        Step step = steps.values().stream().min((o1, o2) -> new StepsComparator().compare(o1, o2)).get().get(0);
+        LOGGER.info("step to perform: " + step);
+        //2. Cut all the step delta cells from pizza
+        LOGGER.info("pizza before step: " + pizza
+                + "\ndelta to remove from the pizza: " + step.delta);
+        pizza.getCells().removeAll(step.delta.cells);
+        LOGGER.info("pizza after step:" + pizza);
+        //3. Add the step cells to an output slice
+        Slice slice = new Slice(step.delta.cells);
+        slice.cells.addAll(step.startPosition.cells);
+        return slice;
     }
 
     /**
      * Finds a cells type with minimal cells numbers and generates one cell slices from them
+     * Delete the slices from the pizza
      *
      * @param pizza given pizza
      * @return slices that are start positions for future slicing
@@ -109,15 +84,26 @@ public static List<Slice> cutAllStartPositions(Pizza pizza) {
         LOGGER.info("cutAllStartPositions for pizza: " + pizza
                 + "\nmushrooms number: " + mushrooms.size()
                 + "\ntomatoes number: " + tomatoes.size());
+        List<Slice> startPositions = null;
         if (mushrooms.size() > tomatoes.size()) {
-            return tomatoes.stream()
+            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);
         } else {
-            return mushrooms.stream()
+            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);
         }
+        LOGGER.info("pizza without start positions:" + pizza);
+        return startPositions;
     }
 
 }

src/test/java/com/google/hashcode/entity/PizzaTest.java

@@ -6,9 +6,11 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.util.Optional;
 
 import static com.google.hashcode.utils.InputFiles.EXAMPLE_INPUT_FILE_PATH;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 
 /**
  * @author Grigoriy Lyashenko (Grog).
@@ -24,12 +26,13 @@ public void setup() throws IOException {
 
     @Test
     public void getCell() throws Exception {
-        assertEquals(examplePizza.getCell(0, 0), new Cell(0, 0, Ingredient.TOMATO));
+        assertEquals(examplePizza.getCell(0, 0), Optional.of(new Cell(0, 0, Ingredient.TOMATO)));
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public void getCellException() throws Exception {
-        examplePizza.getCell(100500, 0);
+        Optional<Cell> cell = examplePizza.getCell(100500, 0);
+        assertFalse(cell.isPresent());
     }
 
     @Test

src/test/java/com/google/hashcode/utils/DFSMethodsTest.java

@@ -6,7 +6,6 @@
 
 import java.io.File;
 import java.io.IOException;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
@@ -26,18 +25,6 @@ public void setup() throws IOException {
         pizza = new Pizza(new File(EXAMPLE_INPUT_FILE_PATH), IoUtils.parsePizza(EXAMPLE_INPUT_FILE_PATH), IoUtils.parseSliceInstructions(EXAMPLE_INPUT_FILE_PATH));
     }
 
-    @Test
-    public void rightStep() throws Exception {
-        //then perform a step right from a particular cell
-        Slice actualSlice = DFSMethods.rightStep(pizza, new Slice(pizza.getCell(1, 3))).get();
-        Slice expectedSlice = new Slice(Arrays.asList(new Cell(1, 3, Ingredient.MUSHROOM), new Cell(1, 4, Ingredient.TOMATO)));
-        assertEquals(expectedSlice, actualSlice);
-        //and slice has been removed from the pizza
-        ArrayList<Cell> expectedPizzaCells = new ArrayList<>(pizza.getCells());
-        expectedPizzaCells.removeAll(expectedSlice.cells);
-        assertEquals(expectedPizzaCells, pizza.getCells());
-    }
-
     @Test
     public void getAvailableSteps() throws IOException {
         Map<Slice, List<Step>> actualMap = DFSMethods.getAvailableSteps(pizza, DFSMethods.cutAllStartPositions(pizza));
@@ -55,12 +42,14 @@ public void cutAllStartPositions() throws IOException {
                 new Slice(new Cell(1, 3, Ingredient.MUSHROOM))
         );
         assertEquals(expected, DFSMethods.cutAllStartPositions(pizza));
+        assertEquals("We expect pizza size reduced to 15-3=12", 12, pizza.getCells().size());
     }
 
     @Test
     public void performStep() {
-        //TODO finish the method implementation
-        List<Step> minSteps = DFSMethods.performStep(pizza, DFSMethods.getAvailableSteps(pizza, DFSMethods.cutAllStartPositions(pizza)));
-        System.err.println(minSteps);
+        List<Slice> output = DFSMethods.cutAllStartPositions(pizza);
+        Slice slice = DFSMethods.performStep(pizza, DFSMethods.getAvailableSteps(pizza, output));
+        assertEquals(new Slice(Arrays.asList(new Cell(0, 2, Ingredient.TOMATO), new Cell(1, 2, Ingredient.MUSHROOM))), slice);
+        assertEquals(11, pizza.getCells().size());
     }
 }