Merge remote-tracking branch 'remotes/origin/DFS_performStep' into DFSmethods

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

@@ -19,8 +19,8 @@ public class Slice {
     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) {
@@ -110,7 +110,7 @@ public Slice generateStepDeltaBelow() {
     public Slice generateStepDeltaLeft() {
         List<Cell> delta = new ArrayList<>();
         for (int y = this.minY(); y <= this.maxY(); y++) {
-            Cell cell = new Cell(y, minX() -1 , Ingredient.TOMATO);
+            Cell cell = new Cell(y, minX() - 1, Ingredient.TOMATO);
             delta.add(cell);
         }
         LOGGER.info("generateStepDeltaLeft"

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

@@ -8,22 +8,21 @@
  */
 public class Step {
 
-    public Step(Slice startPosition, Slice delta) {
-		super();
-		this.startPosition = startPosition;
-		this.delta = delta;
-	}
-
-	public Slice startPosition;
-
+    public Slice startPosition;
     public Slice delta;
 
-	@Override
-	public String toString() {
-		return "Step{" +
-				"startPosition=" + startPosition +
-				", delta=" + delta +
-				'}';
-	}
+    public Step(Slice startPosition, Slice delta) {
+        super();
+        this.startPosition = startPosition;
+        this.delta = delta;
+    }
+
+    @Override
+    public String toString() {
+        return "Step{" +
+                "startPosition=" + startPosition +
+                ", delta=" + delta +
+                '}';
+    }
 
 }

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
      *
@@ -79,13 +44,32 @@ public static Map<Slice, List<Step>> getAvailableSteps(Pizza pizza, List<Slice>
         return groupedSteps;
     }
 
-    public static Slice performStep(Pizza pizza, List<Step> steps) {
-        //TODO pick-ups a step with a minimal steps number, execute it(cut it from the pizza, and a slice)
-        return null;
+    /**
+     * Pick-ups a step with a minimal cells delta number,
+     * execute it(cut it from the pizza, and add to a slice)
+     *
+     * @param pizza given pizza
+     * @param steps available steps
+     * @return formed slice that includes an original slice and delta from a step
+     */
+    public static Slice performStep(Pizza pizza, Map<Slice, List<Step>> steps) {
+        //1. Pick ups a steps list with minimal total cells number
+        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
@@ -100,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/main/java/com/google/hashcode/utils/StepsComparator.java

@@ -0,0 +1,23 @@
+package com.google.hashcode.utils;
+
+import com.google.hashcode.entity.Step;
+
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * @author Grigoriy Lyashenko (Grog).
+ */
+public class StepsComparator implements Comparator<List<Step>> {
+
+    @Override
+    public int compare(List<Step> o1, List<Step> o2) {
+        long o1CellsCount = o1.stream()
+                .flatMap(step -> step.delta.cells.stream())
+                .count();
+        long o2CellsCount = o2.stream()
+                .flatMap(step -> step.delta.cells.stream())
+                .count();
+        return Long.compare(o1CellsCount, o2CellsCount);
+    }
+}

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

@@ -1,11 +1,11 @@
 package com.google.hashcode.utils;
 
 import com.google.hashcode.entity.*;
+import org.junit.Before;
 import org.junit.Test;
 
 import java.io.File;
 import java.io.IOException;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
@@ -18,39 +18,38 @@
  */
 public class DFSMethodsTest {
 
-    @Test
-    public void rightStep() throws Exception {
-        //Given a pizza
-        Pizza pizza = new Pizza(new File(EXAMPLE_INPUT_FILE_PATH), IoUtils.parsePizza(EXAMPLE_INPUT_FILE_PATH), IoUtils.parseSliceInstructions(EXAMPLE_INPUT_FILE_PATH));
-        //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());
+    private Pizza pizza;
+
+    @Before
+    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 getAvailableSteps() throws IOException {
-        Pizza pizza = new Pizza(new File(EXAMPLE_INPUT_FILE_PATH), IoUtils.parsePizza(EXAMPLE_INPUT_FILE_PATH), IoUtils.parseSliceInstructions(EXAMPLE_INPUT_FILE_PATH));
         Map<Slice, List<Step>> actualMap = DFSMethods.getAvailableSteps(pizza, DFSMethods.cutAllStartPositions(pizza));
         assertEquals(3, actualMap.keySet().size());
-        assertEquals(3, actualMap.get(new Slice(new Cell(1,1, Ingredient.MUSHROOM))).size());
-        assertEquals(2, actualMap.get(new Slice(new Cell(1,2, Ingredient.MUSHROOM))).size());
-        assertEquals(3, actualMap.get(new Slice(new Cell(1,3, Ingredient.MUSHROOM))).size());
+        assertEquals(3, actualMap.get(new Slice(new Cell(1, 1, Ingredient.MUSHROOM))).size());
+        assertEquals(2, actualMap.get(new Slice(new Cell(1, 2, Ingredient.MUSHROOM))).size());
+        assertEquals(3, actualMap.get(new Slice(new Cell(1, 3, Ingredient.MUSHROOM))).size());
     }
 
     @Test
     public void cutAllStartPositions() throws IOException {
-        Pizza pizza = new Pizza(new File(EXAMPLE_INPUT_FILE_PATH), IoUtils.parsePizza(EXAMPLE_INPUT_FILE_PATH), IoUtils.parseSliceInstructions(EXAMPLE_INPUT_FILE_PATH));
         List<Slice> expected = Arrays.asList(
                 new Slice(new Cell(1, 1, Ingredient.MUSHROOM)),
                 new Slice(new Cell(1, 2, Ingredient.MUSHROOM)),
                 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() {
+        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());
+    }
 }