DFSmethod. Add necessary methods to get pizza cell by coordinates, minor refactoring

Author: LyashenkoGS

src/main/java/com/google/hashcode/App.java

@@ -11,14 +11,14 @@
 import java.io.IOException;
 import java.util.List;
 
+import static com.google.hashcode.utils.InputFiles.EXAMPLE_INPUT_FILE_PATH;
+
 
 public class App {
     private static final Logger LOGGER = LoggerFactory.getLogger(Slicer.class);
 
     public static void main(String[] args) throws IOException {
-        String exampleInputFile = "inputDataSets/example.in";
-        List<Cell> ingredients = IoUtils.parsePizza(exampleInputFile);
-        Pizza pizza = new Pizza(new File(exampleInputFile), ingredients, IoUtils.parseSliceInstructions(exampleInputFile));
+        Pizza pizza = new Pizza(new File(EXAMPLE_INPUT_FILE_PATH), IoUtils.parsePizza(EXAMPLE_INPUT_FILE_PATH), IoUtils.parseSliceInstructions(EXAMPLE_INPUT_FILE_PATH));
         //  IoUtils.writeToFile("outputDataSet/example.txt", IoUtils.parseSlices(Slicer.slicePizza(pizza)));
         LOGGER.info("GoogleHashCode2017! Pizza task");
         LOGGER.info(pizza.toString());

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

@@ -6,9 +6,9 @@
  * @author Grigoriy Lyashenko (Grog).
  */
 public class Cell {
-    public final int x;
-    public final int y;
-    public final Ingredient ingredient;
+    public int x;
+    public int y;
+    public Ingredient ingredient;
     /**
      * indicates if given cell has been sliced
      */
@@ -25,16 +25,8 @@ public String toString() {
         return ingredient.toString();
     }
 
-    /**
-     * Creates a new cell based on the parent but add given coordinates
-     * to the original one cell
-     *
-     * @param x delta x
-     * @param y delta y
-     * @return new Cell with adjusted coordinates
-     */
-    public Cell prototype(int x, int y) {
-        return new Cell(this.x + x, this.y + y, null);
+    public static Cell prototype(int x, int y) {
+        return new Cell(x, y, null);
     }
 
     @Override

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

@@ -1,11 +1,8 @@
 package com.google.hashcode.entity;
 
-import com.google.hashcode.utils.IoUtils;
-
 import java.io.File;
-import java.util.Arrays;
 import java.util.List;
-import java.util.stream.Collectors;
+import java.util.Optional;
 
 /**
  * Represents an immutable pizza
@@ -16,6 +13,13 @@ public class Pizza {
 
     private final File input;
     private final List<Cell> cells;
+    private final SliceInstruction sliceInstruction;
+
+    public Pizza(File input, List<Cell> cells, SliceInstruction sliceInstruction) {
+        this.input = input;
+        this.cells = cells;
+        this.sliceInstruction = sliceInstruction;
+    }
 
     public File getInput() {
         return input;
@@ -25,24 +29,31 @@ public List<Cell> getCells() {
         return cells;
     }
 
-    public SliceInstruction getSliceInstruction() {
-        return sliceInstruction;
+    /**
+     * Coordinates are like in a 2D array
+     *
+     * @param y - row number, 0..max row number
+     * @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);
     }
 
-    private final SliceInstruction sliceInstruction;
-
-    public Pizza(File input, List<Cell> cells, SliceInstruction sliceInstruction) {
-        this.input = input;
-        this.cells = cells;
-        this.sliceInstruction = sliceInstruction;
+    public SliceInstruction getSliceInstruction() {
+        return sliceInstruction;
     }
 
     @Override
     public String toString() {
         return input.toString() +
-             //TODO fix human readable output   "\n" + IoUtils.convertToHumanReadableTable(cells) +
+                //TODO fix human readable output   "\n" + IoUtils.convertToHumanReadableTable(cells) +
                 "\n" + sliceInstruction.toString();
     }
 
-
 }

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

@@ -1,6 +1,8 @@
 package com.google.hashcode.entity;
 
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
 import java.util.List;
 
 /**
@@ -12,13 +14,32 @@ public class Slice {
 
     public List<Cell> cells = new ArrayList<>();
 
-    public void add(Cell cell) {
-        cells.add(cell);
-        cell.sliced = true;
+    public Slice() {
     }
 
-    public int cellsNumber() {
-        return cells.size();
+    public Slice(Cell cell) {
+        this.cells = Collections.singletonList(cell);
+    }
+
+    public int minX() {
+        return Collections.min(cells, Comparator.comparingInt(Cell::getX)).x;
+    }
+
+    public int minY() {
+        return Collections.min(cells, Comparator.comparingInt(Cell::getX)).y;
+    }
+
+    public int maxX() {
+        return Collections.max(cells, Comparator.comparingInt(Cell::getX)).x;
+    }
+
+
+   /* public Slice(Cell cell) {
+        this.cells = Collections.singletonList(cell);
+    }*/
+
+    public int maxY() {
+        return Collections.max(cells, Comparator.comparingInt(Cell::getX)).y;
     }
 
     @Override

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

@@ -1,187 +1,59 @@
 package com.google.hashcode.utils;
 
 import com.google.hashcode.entity.Cell;
+import com.google.hashcode.entity.Pizza;
+import com.google.hashcode.entity.Slice;
+import com.google.hashcode.entity.SliceInstruction;
 
 import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
 import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
 
-public class DFSMethods {
-
-    public int CalculateNumberOfFreeCellsAroundSlice(List<Cell> slice, List<Cell> pizza) {
-        int cellsAroundSlice = 0;
-        //found coordinates of slice angles.
-        int minX = findMinX(slice);
-        int minY = findMinY(slice);
-        int maxX = findMaxX(slice);
-        int maxY = findMaxY(slice);
-        //generate arrays of x and y coordinates for this slice.
-        List<Integer> differenceXCoordinates = fillArrayWithIntValues(minX, maxX);
-        List<Integer> differenceYCoordinates = fillArrayWithIntValues(minY, maxY);
-        //checking top cells.
-        if (didPizzaContainsAllNeededHorizontalCells(pizza, differenceXCoordinates, minY - 1))
-            cellsAroundSlice += differenceXCoordinates.size();
-        //checking left cells.
-        if (didPizzaContainsAllNeededVerticalCells(pizza, differenceYCoordinates, maxX + 1))
-            cellsAroundSlice += differenceYCoordinates.size();
-        //checking bottom cells.
-        if (didPizzaContainsAllNeededHorizontalCells(pizza, differenceXCoordinates, maxY + 1))
-            cellsAroundSlice += differenceXCoordinates.size();
-        //checking right cells.
-        if (didPizzaContainsAllNeededVerticalCells(pizza, differenceYCoordinates, minX - 1))
-            cellsAroundSlice += differenceYCoordinates.size();
-        return cellsAroundSlice;
-    }
-
-    //region steps
-
-    public boolean stepUp(List<Cell> slice, List<Cell> pizza, int maxCellsInSlice) {
-        // finding min y coordinate in slice.
-        Integer minYCoordInSlice = findMinY(slice);
-        // find all difference x coordinates.
-        List<Integer> differenceXCoordinates = fillAllDifferenceX(slice);
-        //prevent this method from cutting too big slice.
-        if (slice.size() + differenceXCoordinates.size() > maxCellsInSlice) return false;
-        //our pizza still have all needed cells for this step? lets check it.
-        boolean pizzaContainsAllNeededCells = didPizzaContainsAllNeededHorizontalCells(pizza, differenceXCoordinates, minYCoordInSlice - 1);
-        if (pizzaContainsAllNeededCells) {
-            //Cut all needed cells from pizza and add their to our slice.
-            for (int xCoord : differenceXCoordinates) {
-                //use .remove(index) to get object from pizza (with it's Ingradient)
-                //but for getting those index use .indexOf(Object o)
-                //TODO fix a compile time error. slice.add(pizza.remove(pizza.indexOf(new Cell(xCoord, minYCoordInSlice))))
-            }
-            return true;
-        } else {
-            //oups, pizza doesn't contain one of needed cells, step blocked.
-            return false;
-        }
-    }
-
-    public boolean stepRight(List<Cell> slice, List<Cell> pizza, int maxCellsInSlice) {
-        //TODO fix a compile time error
-        /*
-        Integer maxXCoordInSlice = findMaxX(slice);
-        List<Integer> differenceYCoordinates = fillAllDifferenceY(slice);
-        ;
-        if (slice.size() + differenceYCoordinates.size() > maxCellsInSlice) return false;
-        boolean pizzaContainsAllNeededCells = didPizzaContainsAllNeededVerticalCells(pizza, differenceYCoordinates, maxXCoordInSlice + 1);
-        if (pizzaContainsAllNeededCells) {
-            for (int yCoord : differenceYCoordinates) {
-                slice.add(pizza.remove(pizza.indexOf(new Cell(minXCoordInSlice, yCoord))))
-            }
-            return true;
-        } else {
-            return false;
-        }*/
-        return true;
-    }
-
-    public boolean stepDown(List<Cell> slice, List<Cell> pizza, int maxCellsInSlice) {
-        //TODO fix a compile time error
-        /*     Integer maxYCoordInSlice = findMaxY(slice);
-        List<Integer> differenceXCoordinates = fillAllDifferenceX(slice);
-        if (slice.size() + differenceXCoordinates.size() > maxCellsInSlice) return false;
-        boolean pizzaContainsAllNeededCells = didPizzaContainsAllNeededVerticalCells(pizza, differenceXCoordinates, maxYCoordInSlice + 1);
-        if (pizzaContainsAllNeededCells) {
-            for (int xCoord : differenceXCoordinates) {
-                slice.add(pizza.remove(pizza.indexOf(new Cell(xCoord, maxYCoordInSlice))))
-            }
-            return true;
-        } else {
-            return false;
-        }*/
-        return true;
-    }
-
-    public boolean stepLeft(List<Cell> slice, List<Cell> pizza, int maxCellsInSlice) {
-        //TODO fix a compile time error
-      /*  Integer minXCoordInSlice = findMinX(slice);
-        List<Integer> differenceYCoordinates = fillAllDifferenceY(slice);
-        if (slice.size() + differenceYCoordinates.size() > maxCellsInSlice) return false;
-        boolean pizzaContainsAllNeededCells = didPizzaContainsAllNeededVerticalCells(pizza, differenceYCoordinates, minXCoordInSlice - 1);
-        if (pizzaContainsAllNeededCells) {
-            for (int yCoord : differenceYCoordinates) {
-                slice.add(pizza.remove(pizza.indexOf(new Cell(minXCoordInSlice, yCoord))))
-            }
-            return true;
-        } else {
-            return false;
-        }*/
-        return true;
+public abstract class DFSMethods {
+    private DFSMethods() {
     }
-    //endregion
 
-    //region utils
+    /**
+     * Calculates a number of cells around the given slice. Available cells is cells that can be merged
+     * into the slice, so it will remain a rectangle, so only up,down,left,right around an each slice outside cell.
+     * No on the diagonal !
+     *
+     * @param slice given pizza
+     * @param pizza given slice
+     * @return number of cells available to merge into the slice
+     */
+    public static int calculateNumberOfFreeCellsAroundSlice(Slice slice, Pizza pizza) {
 
-    private List<Integer> fillAllDifferenceX(List<Cell> slice) {
-        List<Integer> diffX = new ArrayList<Integer>();
-        for (Cell cell : slice) {
-            if (!diffX.contains(cell.x)) {
-                diffX.add(cell.x);
-            }
-        }
-        return diffX;
+        return 0;
     }
 
-    private List<Integer> fillAllDifferenceY(List<Cell> slice) {
-        List<Integer> diffY = new ArrayList<Integer>();
-        for (Cell cell : slice) {
-            if (!diffY.contains(cell.y)) {
-                diffY.add(cell.y);
-            }
-        }
-        return diffY;
-    }
-
-    private List<Integer> fillArrayWithIntValues(int start, int end) {
-        List<Integer> returnedList = new ArrayList<>();
-        for (int i = start; i < end + 1; i++) {
-            returnedList.add((Integer) i);
-        }
-        return returnedList;
-    }
-
-    private int findMinY(List<Cell> slice) {
-        return Collections.min(slice, Comparator.comparingInt(Cell::getX)).y;
-    }
+    public static Optional<Slice> rightStep(Pizza pizza, Slice slice) {
+        List<Cell> rightSlideBorder = 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
+        boolean presentsAvailableCellsInPizza = rightSlideBorder.stream()
+                .allMatch(cell -> pizza.getCells().contains(Cell.prototype(cell.x, cell.y)));
 
-    private int findMaxY(List<Cell> slice) {
-        return Collections.max(slice, Comparator.comparingInt(Cell::getX)).y;
-    }
-
-    private int findMinX(List<Cell> slice) {
-        return Collections.min(slice, Comparator.comparingInt(Cell::getX)).x;
-    }
-
-    private int findMaxX(List<Cell> slice) {
-        return Collections.max(slice, Comparator.comparingInt(Cell::getX)).x;
-    }
+        //check is step is valid
+        SliceInstruction sliceInstruction = pizza.getSliceInstruction();
 
-    private boolean didPizzaContainsAllNeededHorizontalCells(List<Cell> pizza, List<Integer> differenceXCoordinate, Integer yCoord) {
-        //TODO fix a compile time error
-       /* boolean returnValue = true;
-        for (Integer xCoord : differenceXCoordinate) {
-            if (!pizza.contains(new Cell(xCoord, yCoord))) {
-                returnValue = false;
-            }
-        }
-        return returnValue;*/
-        return true;
+        return Optional.empty();
     }
 
-    private boolean didPizzaContainsAllNeededVerticalCells(List<Cell> pizza, List<Integer> differenceYCoordinate, Integer xCoord) {
-        //TODO fix a compile time error
-     /*   boolean returnValue = true;
-        for (Integer yCoord : differenceYCoordinate) {
-            if (!pizza.contains(new Cell(xCoord, yCoord))) {
-                returnValue = false;
-            }
-        }
-        return returnValue;*/
-        return true;
+    /**
+     * Step as an action it's a process, when a slice adding to itself a subset of a pizza cells and remains rectangular.
+     * Step as an entity is a Slice tha can be added to a particular slice inside a particalur pizza
+     * considering slice instructions
+     *
+     * @param pizza            given pizza
+     * @param slice            given slice in the pizza
+     * @param sliceInstruction restrictions for a steps
+     * @return available steps
+     */
+    List<Slice> getAvailableSteps(Pizza pizza, Slice slice, SliceInstruction sliceInstruction) {
+        return new ArrayList<>();
     }
 
-    //endregion
 }