added some improvements before hashcode 2019

Author: linnykoleh

README.md

@@ -1,11 +1,9 @@
 # TeamPizza
-Google hashcode task
-Pizza
-Practice Problem for Hash Code 2017
 
-(Project contains all examples and description is pdf format)
+### Practice Problem for Google Hash Code 2017
 
 ### Introduction
+
 Did you know that at any given time, someone is cutting pizza somewhere around the world? The decision
 about how to cut the pizza sometimes is easy, but sometimes it’s really hard: you want just the right amount
 of tomatoes and mushrooms on each slice. If only there was a way to solve this problem using technology...
@@ -41,27 +39,18 @@ lines terminated with a single ‘\n’ character at the end of each line (UNIX-
 
 The file consists of:
  - one line containing the following natural numbers separated by single spaces:
- - R (1 ≤ R ≤ 1000) is the number of rows
- - C (1 ≤ C ≤ 1000) is the number of columns
- - L (1 ≤ L ≤ 1000) is the minimum number of each ingredient cells in a slice
- - H (1 ≤ H ≤ 1000) is the maximum total number of cells of a slice
- 
-*Google 2017, All rights reserved.*
+	 - R (1 ≤ R ≤ 1000) is the number of rows
+	 - C (1 ≤ C ≤ 1000) is the number of columns
+	 - L (1 ≤ L ≤ 1000) is the minimum number of each ingredient cells in a slice
+	 - H (1 ≤ H ≤ 1000) is the maximum total number of cells of a slice
 
-R lines describing the rows of the pizza (one after another). Each of these lines contains C
+ - R lines describing the rows of the pizza (one after another). Each of these lines contains C
 characters describing the ingredients in the cells of the row (one cell after another). Each character
 is either ‘M’ (for mushroom) or ‘T’ (for tomato).
 
 **Example**
 
-- 3 5 1 6
-- TTTTT
-- TMMMT
-- TTTTT
-
-3 rows, 5 columns, min 1 of each ingredient per slice, max 6 cells per slice
-
-**Example input file.**
+![alt](images/Screenshot.png)
 
 **Submissions**
 
@@ -72,23 +61,11 @@ The file must consist of:
 - U lines describing the slices. Each of these lines must contain the following natural numbers separated by single spaces:
 -  r 1 , c 1 , r 2 , c 2 describe a slice of pizza delimited by the rows r (0 ≤ r1,r2 < R, 0 ≤ c1, c2 < C) 1 and r 2 and the columns c 1 and c 2 , including the cells of the delimiting rows and columns. The rows ( r 1 and r 2 ) can be given in any order. The columns ( c 1 and c 2 ) can be given in any order too.
 
-**Example**
-
-- 0 0 2 1
-- 0 2 2 2
-- 0 3 2 4
 
-3 slices.
-- First slice between rows (0,2) and columns (0,1).
-- Second slice between rows (0,2) and columns (2,2).
-- Third slice between rows (0,2) and columns (3,4).
-- Example submission file.
-
-*© Google 2017, All rights reserved.*
-
-Slices described in the example submission file marked in green, orange and purple.
+![alt](images/Screenshot_1.png)
 
 ### Validation
+
 For the solution to be accepted:
 - the format of the file must match the description above,
 - each cell of the pizza must be included in at most one slice,
@@ -97,9 +74,11 @@ For the solution to be accepted:
 - total area of each slice must be at most H
 
 ### Scoring
+
 The submission gets a score equal to the total number of cells in all slices.
 Note that there are multiple data sets representing separate instances of the problem. The final
 score for your team is the sum of your best scores on the individual data sets.
 
 ### Scoring example
+
 The example submission file given above cuts the slices of 6, 3 and 6 cells, earning 6 + 3 + 6 = 15 points.

images/Screenshot.png

@@ -16,10 +16,11 @@ public BestPosition(int rows, int columns, char[][] matrixCopy) {
 		findBestPositions();
 	}
 
-	private void findBestPositions(){
-		finish : for(int c = 0; c < columns; c++) {
+	private void findBestPositions() {
+		finish:
+		for (int c = 0; c < columns; c++) {
 			for (int r = 0; r < rows; r++) {
-				if('*' != matrixCopy[r][c]){
+				if ('*' != matrixCopy[r][c]) {
 					bestRow = r;
 					bestColumn = c;
 					break finish;

images/Screenshot_1.png

@@ -10,12 +10,12 @@ public MinEachIngredient(int minEachIngredient) {
 		this.minEachIngredient = minEachIngredient;
 	}
 
-	public boolean isEnough(char ingredient){
+	public boolean isEnough(char ingredient) {
 		final int tomato = array[0];
 		final int mushrooms = array[1];
-		if('T' == ingredient){
+		if ('T' == ingredient) {
 			array[0] = tomato + 1;
-		}else if('M' == ingredient){
+		} else if ('M' == ingredient) {
 			array[1] = mushrooms + 1;
 		}
 		return array[0] >= minEachIngredient && array[1] >= minEachIngredient;

src/main/java/com/team/hashcode/pizza/BestPosition.java

@@ -17,49 +17,49 @@
  * */
 public class Pizza {
 
-    private char[][] matrix;
-    private char[][] matrixCopy;
-    private int maxCellsPerSlice;
+	private char[][] matrix;
+	private char[][] matrixCopy;
+	private int maxCellsPerSlice;
 	private int minEachIngredient;
 	private final List<Slice> slices = new ArrayList<>();
 
-    private int rows;
-    private int columns;
+	private int rows;
+	private int columns;
 
-    public Pizza(char[][] matrix, int maxCellsPerSlice, int minEachIngredient) {
-        this.matrix = matrix;
-        this.matrixCopy = matrix;
-        this.maxCellsPerSlice = maxCellsPerSlice;
+	public Pizza(char[][] matrix, int maxCellsPerSlice, int minEachIngredient) {
+		this.matrix = matrix;
+		this.matrixCopy = matrix;
+		this.maxCellsPerSlice = maxCellsPerSlice;
 		this.minEachIngredient = minEachIngredient;
-        this.rows = matrix.length;
-        this.columns = matrix[0].length;
-    }
+		this.rows = matrix.length;
+		this.columns = matrix[0].length;
+	}
 
-	public void cutPizza(){
+	public void cutPizza() {
 		cutPizza(0, 0);
 	}
 
-    private void cutPizza(int r, int c){
-        for(; c < columns; c++) {
-            for(; r < rows; r++){
-                if(isCorrectSlice(c, r)) {
+	private void cutPizza(int r, int c) {
+		for (; c < columns; c++) {
+			for (; r < rows; r++) {
+				if (isCorrectSlice(c, r)) {
 					createSlices(c, r);
-                }else{
+				} else {
 					final BestPosition bestPosition = new BestPosition(rows, columns, matrixCopy);
 					createSlicesByBestPositions(bestPosition.getBestRow(), bestPosition.getBestColumn());
 				}
-            }
-        }
+			}
+		}
 	}
 
-	private void createSlices(int c, int r){
-		for(int c1 = c; c1 < columns; ) {
+	private void createSlices(int c, int r) {
+		for (int c1 = c; c1 < columns; ) {
 			final Slice slice = new Slice(maxCellsPerSlice);
-			for(int r1 = r; r1 < rows; r1++) {
-				if(slice.getArraySize() < maxCellsPerSlice) {
+			for (int r1 = r; r1 < rows; r1++) {
+				if (slice.getArraySize() < maxCellsPerSlice) {
 					slice.addIngredient(matrix[r1][c1], r1, c1);
 					matrixCopy[r1][c1] = '*';
-				}else{
+				} else {
 					c1++;
 					slices.add(slice);
 					break;
@@ -68,83 +68,87 @@ private void createSlices(int c, int r){
 		}
 	}
 
-	private void createSlicesByBestPositions(int bestRow, int bestColumn){
+	private void createSlicesByBestPositions(int bestRow, int bestColumn) {
 		int rows = bestRow + 1;
-		if(rows == this.rows){             // then it bottom
-			for(; bestColumn < columns; bestColumn++) {
-				if(isCorrectSliceByColumns(bestColumn, bestRow)){
+		if (rows == this.rows) {             // then it bottom
+			for (; bestColumn < columns; bestColumn++) {
+				if (isCorrectSliceByColumns(bestColumn, bestRow)) {
 					fillSliceAndMatrixCopyByColumns(bestColumn, bestRow);
 				}
 			}
 		}
 	}
 
-	private void fillSliceAndMatrixCopyByColumns(int c, int r){
+	private void fillSliceAndMatrixCopyByColumns(int c, int r) {
 		final Slice slice = new Slice(maxCellsPerSlice);
-		for(int c1 = c; c1 < columns; c1++) {
-			if(slice.getArraySize() < maxCellsPerSlice) {
+		for (int c1 = c; c1 < columns; c1++) {
+			if (slice.getArraySize() < maxCellsPerSlice) {
 				slice.addIngredient(matrix[r][c1], r, c1);
 				matrixCopy[r][c1] = '*';
-			}else{
+			} else {
 				break;
 			}
 		}
 		slices.add(slice);
 	}
 
-	private boolean isCorrectSlice(int c, int r){
+	private boolean isCorrectSlice(int c, int r) {
 		int sliceSize = 0;
 		boolean isEnoughIngredient = false;
 		final MinEachIngredient eachIngredient = new MinEachIngredient(minEachIngredient);
-		for(; c < columns; c++) {
-			if(r < matrix.length - 1 && c < matrix[0].length - 1) {
+		for (; c < columns; c++) {
+			if (r < matrix.length - 1 && c < matrix[0].length - 1) {
 				for (; r < rows; r++) {
 					char ingredient = matrix[r][c];
 					if (sliceSize < maxCellsPerSlice) {
-						if(eachIngredient.isEnough(ingredient)){
+						if (eachIngredient.isEnough(ingredient)) {
 							isEnoughIngredient = true;
 						}
-						if (sliceSize >= maxCellsPerSlice && !isEnoughIngredient)
+						if (sliceSize >= maxCellsPerSlice && !isEnoughIngredient) {
 							return false;
-						if ('*' == matrixCopy[r][c])
+						}
+						if ('*' == matrixCopy[r][c]) {
 							return false;
+						}
 						sliceSize++;
 					} else {
 						return true;
 					}
 				}
-			}else{
+			} else {
 				break;
 			}
 		}
 		return false;
 	}
 
-	private boolean isCorrectSliceByColumns(int c, int r){
+	private boolean isCorrectSliceByColumns(int c, int r) {
 		int sliceSize = 1;
 		boolean isEnoughIngredient = false;
 		final MinEachIngredient eachIngredient = new MinEachIngredient(minEachIngredient);
-		for(; c < columns; c++) {
+		for (; c < columns; c++) {
 			char ingredient = matrix[r][c];
-			if(sliceSize <= maxCellsPerSlice) {
-				if(eachIngredient.isEnough(ingredient)){
+			if (sliceSize <= maxCellsPerSlice) {
+				if (eachIngredient.isEnough(ingredient)) {
 					isEnoughIngredient = true;
 				}
-				if(sliceSize >= maxCellsPerSlice && !isEnoughIngredient)
+				if (sliceSize >= maxCellsPerSlice && !isEnoughIngredient) {
 					return false;
-				if('*' == matrixCopy[r][c])
+				}
+				if ('*' == matrixCopy[r][c]) {
 					return false;
+				}
 				sliceSize++;
-			}else {
+			} else {
 				return true;
 			}
 		}
 		return true;
 	}
 
-    public List<Slice> getSlices(){
-        return slices;
-    }
+	public List<Slice> getSlices() {
+		return slices;
+	}
 
 	public char[][] getMatrixCopy() {
 		return matrixCopy;

src/main/java/com/team/hashcode/pizza/MinEachIngredient.java

@@ -4,45 +4,46 @@
 
 public class Slice {
 
-    private char[] slicePositions;
-    private int arraySize;
-    private int[] rows;
-    private int[] columns;
-
-    public Slice(int sizeSlice) {
-        this.slicePositions = new char[sizeSlice];
-        this.rows = new int[sizeSlice];
-        this.columns = new int[sizeSlice];
-    }
-
-    public void addIngredient(char value, int r, int c){
-        slicePositions[arraySize] = value;
-        rows[arraySize] = r;
-        columns[arraySize] = c;
-        arraySize++;
-    }
-
-    public int getRowFirst(){
-        return rows[0];
-    }
-
-    public int getColumnsFirst(){
-        return columns[0];
-    }
-
-    public int getRowLast(){
-        return rows[rows.length - 1];
-    }
-    public int getColumnsLast(){
-        return columns[columns.length - 1];
-    }
-
-    public int getArraySize(){
-        return arraySize;
-    }
-
-    @Override
-    public String toString() {
-        return Arrays.toString(slicePositions);
-    }
+	private char[] slicePositions;
+	private int arraySize;
+	private int[] rows;
+	private int[] columns;
+
+	public Slice(int sizeSlice) {
+		this.slicePositions = new char[sizeSlice];
+		this.rows = new int[sizeSlice];
+		this.columns = new int[sizeSlice];
+	}
+
+	public void addIngredient(char value, int r, int c) {
+		slicePositions[arraySize] = value;
+		rows[arraySize] = r;
+		columns[arraySize] = c;
+		arraySize++;
+	}
+
+	public int getRowFirst() {
+		return rows[0];
+	}
+
+	public int getColumnsFirst() {
+		return columns[0];
+	}
+
+	public int getRowLast() {
+		return rows[rows.length - 1];
+	}
+
+	public int getColumnsLast() {
+		return columns[columns.length - 1];
+	}
+
+	public int getArraySize() {
+		return arraySize;
+	}
+
+	@Override
+	public String toString() {
+		return Arrays.toString(slicePositions);
+	}
 }