From 40cfe4a794f21a015c6d46cb289e81128add6fb3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Antonio=20L=C3=B3pez=20Mar=C3=ADn?= Date: Fri, 10 Feb 2017 19:41:25 +0100 Subject: [PATCH 1/6] Created a store that read from file --- build.gradle | 1 + small.in | 7 +++ src/main/kotlin/Main.kt | 3 - src/main/kotlin/storage/Store.kt | 33 +++++++++++ src/test/kotlin/storage/StoreTest.kt | 86 ++++++++++++++++++++++++++++ test.in | 4 ++ 6 files changed, 131 insertions(+), 3 deletions(-) create mode 100644 small.in create mode 100644 src/main/kotlin/storage/Store.kt create mode 100644 src/test/kotlin/storage/StoreTest.kt create mode 100644 test.in diff --git a/build.gradle b/build.gradle index 1728be2..1744c97 100644 --- a/build.gradle +++ b/build.gradle @@ -25,4 +25,5 @@ repositories { dependencies { compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" + testCompile 'junit:junit:4.12' } diff --git a/small.in b/small.in new file mode 100644 index 0000000..42f6ba0 --- /dev/null +++ b/small.in @@ -0,0 +1,7 @@ +6 7 1 5 +TMMMTTT +MMMMTMM +TTMTTMT +TMMTMMM +TTTTTTM +TTTTTTM diff --git a/src/main/kotlin/Main.kt b/src/main/kotlin/Main.kt index ecd1d6d..09dd5ca 100644 --- a/src/main/kotlin/Main.kt +++ b/src/main/kotlin/Main.kt @@ -2,8 +2,5 @@ import model.Pizza class Main { - fun algo () { - val pizza = Pizza(3, 3) - } } \ No newline at end of file diff --git a/src/main/kotlin/storage/Store.kt b/src/main/kotlin/storage/Store.kt new file mode 100644 index 0000000..47e8663 --- /dev/null +++ b/src/main/kotlin/storage/Store.kt @@ -0,0 +1,33 @@ +package storage + +import model.Cell +import model.Pizza +import java.io.File +import java.util.* + +class Store { + + fun read(fileName: String): Pizza { + + val scanner = Scanner(File(fileName)) + + val R = scanner.nextInt() + val C = scanner.nextInt() + val L = scanner.nextInt() + val H = scanner.nextInt() + scanner.nextLine() + + val pizza = Array(R) { index -> + var line = scanner.nextLine() + + val row = Array(C) { index -> + Cell(line[index].toString(), false) + } + + row + } + + return Pizza(pizza, R, C, L, H) + } + +} \ No newline at end of file diff --git a/src/test/kotlin/storage/StoreTest.kt b/src/test/kotlin/storage/StoreTest.kt new file mode 100644 index 0000000..3d20799 --- /dev/null +++ b/src/test/kotlin/storage/StoreTest.kt @@ -0,0 +1,86 @@ +package storage + +import model.Cell +import model.Pizza +import org.hamcrest.core.Is.`is` +import org.junit.Assert.* +import org.junit.Test + +/** + + 3 4 1 5 + TMMM + MMMM + TTTM + + */ +class StoreShould { + + private fun pizza(): Pizza { + val store = Store() + val pizza = store.read("test.in") + return pizza + } + + @Test + fun `read a pizza row information`() { + val pizza = pizza() + + assertThat(pizza.R, `is`(3)) + } + + @Test + fun `read a pizza column information`() { + val pizza = pizza() + + assertThat(pizza.C, `is`(4)) + } + + @Test + fun `read a pizza min ingredients per slice information`() { + val pizza = pizza() + + assertThat(pizza.L, `is`(1)) + } + + @Test + fun `read a pizza max ingredients per slice information`() { + val pizza = pizza() + + assertThat(pizza.H, `is`(5)) + } + + @Test + fun `read a pizza table information`(){ + val pizza = pizza().table + + val expectedPizza = Array(3) { index -> + getExpectedPizzaRow(index) + } + + assertThat(pizza.size, `is`(expectedPizza.size)) + assertThat(pizza, `is`(expectedPizza)) + } + + /** + * TMMM + * MMMM + * TTTM + */ + private fun getExpectedPizzaRow(index: Int): Array { + val firstRow = arrayOf(T(), M(), M(), M()) + val secondRow = arrayOf(M(), M(), M(), M()) + val thirdRow = arrayOf(T(), T(), T(), M()) + + return when(index){ + 0 -> firstRow + 1 -> secondRow + 2 -> thirdRow + else -> firstRow + } + } + + private fun M() = Cell("M", false) + + private fun T() = Cell("T", false) +} \ No newline at end of file diff --git a/test.in b/test.in new file mode 100644 index 0000000..da66944 --- /dev/null +++ b/test.in @@ -0,0 +1,4 @@ +3 4 1 5 +TMMM +MMMM +TTTM From 3e0c2ca41609d5a1f44ec22da89c8cfe0337ce6a Mon Sep 17 00:00:00 2001 From: Cotel Date: Fri, 10 Feb 2017 19:42:49 +0100 Subject: [PATCH 2/6] Starting algorithm --- src/main/kotlin/Main.kt | 26 ++++++-- src/main/kotlin/model/Cell.kt | 2 +- src/main/kotlin/services/SlicerService.kt | 78 +++++++++++++++++++++++ 3 files changed, 101 insertions(+), 5 deletions(-) create mode 100644 src/main/kotlin/services/SlicerService.kt diff --git a/src/main/kotlin/Main.kt b/src/main/kotlin/Main.kt index ecd1d6d..7cd86db 100644 --- a/src/main/kotlin/Main.kt +++ b/src/main/kotlin/Main.kt @@ -1,9 +1,27 @@ +import model.Cell import model.Pizza +import services.SlicerService -class Main { +fun main(args: Array) { + (2..5).forEach(::println) - fun algo () { - val pizza = Pizza(3, 3) + val expected = Array(3) { index -> + when (index) { + 0 -> arrayOf(T(), T(), T(), T(), T()) + 1 -> arrayOf(T(), M(), M(), M(), T()) + 2 -> arrayOf(T(), T(), T(), T(), T()) + else -> arrayOf(T()) + } + } + + val slicer = SlicerService() + val pizza = Pizza(expected, 3, 5, 1, 6) + val slices = slicer.slice(pizza, 1, 6) + for (slice in slices) { + println(slicer.checkSlice(slice, pizza, 1, 6)) } -} \ No newline at end of file +} + +private fun T() = Cell("T", false) +private fun M() = Cell("M", false) \ No newline at end of file diff --git a/src/main/kotlin/model/Cell.kt b/src/main/kotlin/model/Cell.kt index e2d5f93..ebb30d7 100644 --- a/src/main/kotlin/model/Cell.kt +++ b/src/main/kotlin/model/Cell.kt @@ -1,3 +1,3 @@ package model -data class Cell(val ingredient: String, val used: Boolean) \ No newline at end of file +data class Cell(val ingredient: String, var used: Boolean) \ No newline at end of file diff --git a/src/main/kotlin/services/SlicerService.kt b/src/main/kotlin/services/SlicerService.kt new file mode 100644 index 0000000..cba8091 --- /dev/null +++ b/src/main/kotlin/services/SlicerService.kt @@ -0,0 +1,78 @@ +package services + +import model.Pizza +import model.Slice + +class SlicerService { + + fun slice(pizza: Pizza, L: Int, H: Int): Array { + val slices = emptyArray() + + for (row in 0..pizza.R) { + for (column in 0..pizza.C) { + if (!pizza.table[row][column].used) { + + var startingRow = row + var startingColumn = column + var ingredients = 1 + var startingIngredient = pizza.table[row][column].ingredient + var currentSize = 1 + + for (currentRow in startingRow..pizza.R) { + while (currentSize < H) { + var currentColumn = 0 + while (currentColumn < pizza.C) { + if (!pizza.table[currentRow][currentColumn].ingredient.equals(startingIngredient)) ingredients++ + currentSize = (currentRow + 1) * (currentColumn + 1) + currentColumn++ + } + + if (ingredients != L) { + currentSize = (currentRow + 1) + } else { + val slice = Slice(startingRow, currentRow, startingColumn, currentColumn) + slices.plus(slice) + markCellsAsUsed(pizza, startingRow, currentRow, startingColumn, currentColumn) + } + currentColumn = 0 + } + } + + + } + } + } + + return slices + } + + fun checkSlice(slice: Slice, pizza: Pizza, L: Int, H: Int): Boolean { + var ingredients = 0 + val seenIngredients = emptyArray() + for (row in slice.startRow..slice.endRow) { + for (column in slice.startColumn..slice.endColumn) { + if (!seenIngredients.contains(pizza.table[row][column].ingredient)) { + seenIngredients.plus(pizza.table[row][column].ingredient) + ingredients++ + if (ingredients > L) return false + } + } + } + + val sliceSize = ((slice.endColumn - slice.startColumn) + 1) * ((slice.endRow - slice.startRow) + 1) + + return sliceSize <= H && ingredients == L + + } + + private fun markCellsAsUsed(pizza: Pizza, startingRow: Int, endingRow: Int, startingColumn: Int, endingColumn: Int) { + for (row in startingRow..endingRow) { + println("row $row") + for (column in startingColumn..(endingColumn - 1)) { + println("column $column") + pizza.table[row][column].used = true + } + } + } + +} \ No newline at end of file From eb2f1ede86c66824a47afeb5a7ed67145e09abb2 Mon Sep 17 00:00:00 2001 From: Cotel Date: Sat, 11 Feb 2017 11:24:29 +0100 Subject: [PATCH 3/6] Getting incorrect slices --- src/main/kotlin/Main.kt | 8 +-- src/main/kotlin/services/SlicerService.kt | 75 ++++++++++------------- 2 files changed, 36 insertions(+), 47 deletions(-) diff --git a/src/main/kotlin/Main.kt b/src/main/kotlin/Main.kt index 7cd86db..a64b989 100644 --- a/src/main/kotlin/Main.kt +++ b/src/main/kotlin/Main.kt @@ -3,8 +3,6 @@ import model.Pizza import services.SlicerService fun main(args: Array) { - (2..5).forEach(::println) - val expected = Array(3) { index -> when (index) { 0 -> arrayOf(T(), T(), T(), T(), T()) @@ -16,11 +14,9 @@ fun main(args: Array) { val slicer = SlicerService() val pizza = Pizza(expected, 3, 5, 1, 6) - val slices = slicer.slice(pizza, 1, 6) + val slices = slicer.getSlices(pizza) - for (slice in slices) { - println(slicer.checkSlice(slice, pizza, 1, 6)) - } + slices.forEach(::println) } private fun T() = Cell("T", false) diff --git a/src/main/kotlin/services/SlicerService.kt b/src/main/kotlin/services/SlicerService.kt index cba8091..0c0741b 100644 --- a/src/main/kotlin/services/SlicerService.kt +++ b/src/main/kotlin/services/SlicerService.kt @@ -5,71 +5,64 @@ import model.Slice class SlicerService { - fun slice(pizza: Pizza, L: Int, H: Int): Array { - val slices = emptyArray() + fun getSlices(pizza: Pizza): Array { + var slices = emptyArray() - for (row in 0..pizza.R) { - for (column in 0..pizza.C) { + for (row in 0..(pizza.R - 1)) { + for (column in 0..(pizza.C - 1)) { if (!pizza.table[row][column].used) { - - var startingRow = row - var startingColumn = column - var ingredients = 1 - var startingIngredient = pizza.table[row][column].ingredient - var currentSize = 1 - - for (currentRow in startingRow..pizza.R) { - while (currentSize < H) { - var currentColumn = 0 - while (currentColumn < pizza.C) { - if (!pizza.table[currentRow][currentColumn].ingredient.equals(startingIngredient)) ingredients++ - currentSize = (currentRow + 1) * (currentColumn + 1) - currentColumn++ - } - - if (ingredients != L) { - currentSize = (currentRow + 1) - } else { - val slice = Slice(startingRow, currentRow, startingColumn, currentColumn) - slices.plus(slice) - markCellsAsUsed(pizza, startingRow, currentRow, startingColumn, currentColumn) - } - currentColumn = 0 - } + val slice = getSliceFrom(pizza, row, column) + if (slice != null) { + slices = slices.plusElement(slice) } + } + } + } + return slices + } + private fun getSliceFrom(pizza: Pizza, row: Int, column: Int): Slice? { + var currentColumn = column + var currentRow = row + var currentSize = 1 + var numColumns = 1 + + while (currentSize < pizza.H && currentColumn < pizza.C) { + while (currentSize < pizza.H && currentRow < pizza.R) { + val slice = Slice(column, currentColumn, row, currentRow) + if (checkSlice(slice, pizza, pizza.L, pizza.H)) { + markCellsAsUsed(pizza, row, currentRow, column, currentColumn) + return slice } + currentRow++ + currentSize += numColumns } + numColumns++ + currentSize = numColumns } - return slices + return null } fun checkSlice(slice: Slice, pizza: Pizza, L: Int, H: Int): Boolean { - var ingredients = 0 - val seenIngredients = emptyArray() + var mushrooms = 0 + var tomatoes = 0 for (row in slice.startRow..slice.endRow) { for (column in slice.startColumn..slice.endColumn) { - if (!seenIngredients.contains(pizza.table[row][column].ingredient)) { - seenIngredients.plus(pizza.table[row][column].ingredient) - ingredients++ - if (ingredients > L) return false - } + if (pizza.table[row][column].ingredient.equals("M")) mushrooms++ else tomatoes++ } } val sliceSize = ((slice.endColumn - slice.startColumn) + 1) * ((slice.endRow - slice.startRow) + 1) - return sliceSize <= H && ingredients == L + return sliceSize <= H && tomatoes >= L && mushrooms >= L } private fun markCellsAsUsed(pizza: Pizza, startingRow: Int, endingRow: Int, startingColumn: Int, endingColumn: Int) { for (row in startingRow..endingRow) { - println("row $row") - for (column in startingColumn..(endingColumn - 1)) { - println("column $column") + for (column in startingColumn..endingColumn) { pizza.table[row][column].used = true } } From 054f5e9881d5196529e0eb58c93474dc8f0970db Mon Sep 17 00:00:00 2001 From: Cotel Date: Sat, 11 Feb 2017 12:15:34 +0100 Subject: [PATCH 4/6] Getting better slices --- src/main/kotlin/services/SlicerService.kt | 56 ++++++++++++++++++----- 1 file changed, 44 insertions(+), 12 deletions(-) diff --git a/src/main/kotlin/services/SlicerService.kt b/src/main/kotlin/services/SlicerService.kt index 0c0741b..2ba9a42 100644 --- a/src/main/kotlin/services/SlicerService.kt +++ b/src/main/kotlin/services/SlicerService.kt @@ -5,21 +5,21 @@ import model.Slice class SlicerService { - fun getSlices(pizza: Pizza): Array { - var slices = emptyArray() + fun getSlices(pizza: Pizza): List { + var slices: MutableList = emptyList().toMutableList() for (row in 0..(pizza.R - 1)) { for (column in 0..(pizza.C - 1)) { if (!pizza.table[row][column].used) { val slice = getSliceFrom(pizza, row, column) if (slice != null) { - slices = slices.plusElement(slice) + slices.add(slice) } } } } - return slices + return slices.map { slice -> getBetterSlice(pizza, slice) } } private fun getSliceFrom(pizza: Pizza, row: Int, column: Int): Slice? { @@ -28,10 +28,10 @@ class SlicerService { var currentSize = 1 var numColumns = 1 - while (currentSize < pizza.H && currentColumn < pizza.C) { - while (currentSize < pizza.H && currentRow < pizza.R) { + while (currentSize <= pizza.H && currentColumn < pizza.C) { + while (currentSize <= pizza.H && currentRow < pizza.R) { val slice = Slice(column, currentColumn, row, currentRow) - if (checkSlice(slice, pizza, pizza.L, pizza.H)) { + if (checkSlice(slice, pizza)) { markCellsAsUsed(pizza, row, currentRow, column, currentColumn) return slice } @@ -40,12 +40,47 @@ class SlicerService { } numColumns++ currentSize = numColumns + currentRow = 0 + currentColumn++ } return null } - fun checkSlice(slice: Slice, pizza: Pizza, L: Int, H: Int): Boolean { + private fun getBetterSlice(pizza: Pizza, slice: Slice): Slice { + if (checkSliceSize(slice, pizza.H)) { + var currentColumn = slice.endColumn + var currentRow = slice.endRow + 1 + var numColumns = ((slice.endColumn - slice.startColumn) + 1) + var currentSize = numColumns * ((currentRow - slice.startRow) + 1) + + while (currentSize <= pizza.H && currentColumn < pizza.C) { + while (currentSize <= pizza.H && currentRow < pizza.R) { + val betterSlice = Slice(slice.startColumn, currentColumn, slice.startRow, currentRow) + if (checkSlice(betterSlice, pizza)) { + markCellsAsUsed(pizza, betterSlice.startRow, currentRow, betterSlice.startColumn, currentColumn) + return betterSlice + } + currentRow++ + currentSize += numColumns + } + numColumns++ + currentSize = numColumns + currentRow = 0 + currentColumn++ + } + } + + return slice + } + + private fun checkSlice(slice: Slice, pizza: Pizza): Boolean = + checkSliceIngredients(slice, pizza) && checkSliceSize(slice, pizza.H) + + private fun checkSliceSize(slice: Slice, H: Int): Boolean = + ((slice.endColumn - slice.startColumn) + 1) * ((slice.endRow - slice.startRow) + 1) <= H + + private fun checkSliceIngredients(slice: Slice, pizza: Pizza): Boolean { var mushrooms = 0 var tomatoes = 0 for (row in slice.startRow..slice.endRow) { @@ -54,10 +89,7 @@ class SlicerService { } } - val sliceSize = ((slice.endColumn - slice.startColumn) + 1) * ((slice.endRow - slice.startRow) + 1) - - return sliceSize <= H && tomatoes >= L && mushrooms >= L - + return tomatoes >= pizza.L && mushrooms >= pizza.L } private fun markCellsAsUsed(pizza: Pizza, startingRow: Int, endingRow: Int, startingColumn: Int, endingColumn: Int) { From ac35bae08bd23ef0507cb2c33166db7d41b6aff2 Mon Sep 17 00:00:00 2001 From: Cotel Date: Sat, 11 Feb 2017 12:40:14 +0100 Subject: [PATCH 5/6] Merging Slicer with File-Parse --- .gitignore | 5 +++- src/main/kotlin/Main.kt | 28 ++++++++--------------- src/main/kotlin/services/SlicerService.kt | 3 ++- src/main/kotlin/storage/Store.kt | 13 ++++++++++- src/test/kotlin/storage/StoreTest.kt | 20 ++++++++-------- 5 files changed, 38 insertions(+), 31 deletions(-) diff --git a/.gitignore b/.gitignore index 3082e46..5c8af5d 100644 --- a/.gitignore +++ b/.gitignore @@ -73,4 +73,7 @@ atlassian-ide-plugin.xml /*.log # oh-my-zsh gradle plugin -.gradletasknamecache \ No newline at end of file +.gradletasknamecache + +# Example files +*.out \ No newline at end of file diff --git a/src/main/kotlin/Main.kt b/src/main/kotlin/Main.kt index a64b989..7f9b743 100644 --- a/src/main/kotlin/Main.kt +++ b/src/main/kotlin/Main.kt @@ -1,23 +1,15 @@ -import model.Cell -import model.Pizza import services.SlicerService +import storage.Store fun main(args: Array) { - val expected = Array(3) { index -> - when (index) { - 0 -> arrayOf(T(), T(), T(), T(), T()) - 1 -> arrayOf(T(), M(), M(), M(), T()) - 2 -> arrayOf(T(), T(), T(), T(), T()) - else -> arrayOf(T()) + val files = arrayOf("small", "medium", "example", "big") + val store = Store() + val slicer = SlicerService() + files.forEach { file -> + run { + val pizza = store.read("$file.in") + val slices = slicer.getSlices(pizza) + store.write("$file.out", slices) } } - - val slicer = SlicerService() - val pizza = Pizza(expected, 3, 5, 1, 6) - val slices = slicer.getSlices(pizza) - - slices.forEach(::println) -} - -private fun T() = Cell("T", false) -private fun M() = Cell("M", false) \ No newline at end of file +} \ No newline at end of file diff --git a/src/main/kotlin/services/SlicerService.kt b/src/main/kotlin/services/SlicerService.kt index 2ba9a42..b21c750 100644 --- a/src/main/kotlin/services/SlicerService.kt +++ b/src/main/kotlin/services/SlicerService.kt @@ -19,7 +19,8 @@ class SlicerService { } } - return slices.map { slice -> getBetterSlice(pizza, slice) } + return slices + //return slices.map { slice -> getBetterSlice(pizza, slice) } } private fun getSliceFrom(pizza: Pizza, row: Int, column: Int): Slice? { diff --git a/src/main/kotlin/storage/Store.kt b/src/main/kotlin/storage/Store.kt index 47e8663..b173cd9 100644 --- a/src/main/kotlin/storage/Store.kt +++ b/src/main/kotlin/storage/Store.kt @@ -2,7 +2,9 @@ package storage import model.Cell import model.Pizza +import model.Slice import java.io.File +import java.io.PrintWriter import java.util.* class Store { @@ -20,7 +22,7 @@ class Store { val pizza = Array(R) { index -> var line = scanner.nextLine() - val row = Array(C) { index -> + val row = Array(C) { index -> Cell(line[index].toString(), false) } @@ -30,4 +32,13 @@ class Store { return Pizza(pizza, R, C, L, H) } + fun write(fileName: String, slices: List) { + val writer = PrintWriter(File(fileName)) + + writer.println("${slices.size}") + slices.forEach { slice -> + writer.println("${slice.startRow} ${slice.endRow} ${slice.startColumn} ${slice.endColumn}") + } + } + } \ No newline at end of file diff --git a/src/test/kotlin/storage/StoreTest.kt b/src/test/kotlin/storage/StoreTest.kt index 3d20799..97240f8 100644 --- a/src/test/kotlin/storage/StoreTest.kt +++ b/src/test/kotlin/storage/StoreTest.kt @@ -3,22 +3,22 @@ package storage import model.Cell import model.Pizza import org.hamcrest.core.Is.`is` -import org.junit.Assert.* +import org.junit.Assert.assertThat import org.junit.Test /** - 3 4 1 5 - TMMM - MMMM - TTTM +3 4 1 5 +TMMM +MMMM +TTTM */ class StoreShould { private fun pizza(): Pizza { val store = Store() - val pizza = store.read("test.in") + val pizza = store.read("src/test.in") return pizza } @@ -51,7 +51,7 @@ class StoreShould { } @Test - fun `read a pizza table information`(){ + fun `read a pizza table information`() { val pizza = pizza().table val expectedPizza = Array(3) { index -> @@ -68,11 +68,11 @@ class StoreShould { * TTTM */ private fun getExpectedPizzaRow(index: Int): Array { - val firstRow = arrayOf(T(), M(), M(), M()) + val firstRow = arrayOf(T(), M(), M(), M()) val secondRow = arrayOf(M(), M(), M(), M()) - val thirdRow = arrayOf(T(), T(), T(), M()) + val thirdRow = arrayOf(T(), T(), T(), M()) - return when(index){ + return when (index) { 0 -> firstRow 1 -> secondRow 2 -> thirdRow From 5c781e5e9339f76a542b4b3cb58feb91155ded23 Mon Sep 17 00:00:00 2001 From: Cotel Date: Wed, 15 Feb 2017 15:02:36 +0100 Subject: [PATCH 6/6] Improving submission results --- src/main/kotlin/Main.kt | 10 ++++++++-- src/main/kotlin/model/Slice.kt | 8 +++++++- src/main/kotlin/services/SlicerService.kt | 3 +-- src/main/kotlin/storage/Store.kt | 11 +++++------ 4 files changed, 21 insertions(+), 11 deletions(-) diff --git a/src/main/kotlin/Main.kt b/src/main/kotlin/Main.kt index 7f9b743..e58f249 100644 --- a/src/main/kotlin/Main.kt +++ b/src/main/kotlin/Main.kt @@ -1,14 +1,20 @@ import services.SlicerService import storage.Store +val store = Store() +var slicer = SlicerService() + fun main(args: Array) { + todos() +} + +fun todos() { val files = arrayOf("small", "medium", "example", "big") - val store = Store() - val slicer = SlicerService() files.forEach { file -> run { val pizza = store.read("$file.in") val slices = slicer.getSlices(pizza) + println("$file: ${slices.fold(0) { total, next -> total + next.getScore() }}") store.write("$file.out", slices) } } diff --git a/src/main/kotlin/model/Slice.kt b/src/main/kotlin/model/Slice.kt index 0499096..532c47b 100644 --- a/src/main/kotlin/model/Slice.kt +++ b/src/main/kotlin/model/Slice.kt @@ -3,4 +3,10 @@ package model data class Slice(val startColumn: Int, val endColumn: Int, val startRow: Int, - val endRow: Int) \ No newline at end of file + val endRow: Int) { + + fun getScore(): Int { + return ((this.endColumn - this.startColumn) + 1) * ((this.endRow - this.startRow) + 1) + } + +} \ No newline at end of file diff --git a/src/main/kotlin/services/SlicerService.kt b/src/main/kotlin/services/SlicerService.kt index b21c750..2ba9a42 100644 --- a/src/main/kotlin/services/SlicerService.kt +++ b/src/main/kotlin/services/SlicerService.kt @@ -19,8 +19,7 @@ class SlicerService { } } - return slices - //return slices.map { slice -> getBetterSlice(pizza, slice) } + return slices.map { slice -> getBetterSlice(pizza, slice) } } private fun getSliceFrom(pizza: Pizza, row: Int, column: Int): Slice? { diff --git a/src/main/kotlin/storage/Store.kt b/src/main/kotlin/storage/Store.kt index b173cd9..d02518c 100644 --- a/src/main/kotlin/storage/Store.kt +++ b/src/main/kotlin/storage/Store.kt @@ -4,7 +4,6 @@ import model.Cell import model.Pizza import model.Slice import java.io.File -import java.io.PrintWriter import java.util.* class Store { @@ -33,11 +32,11 @@ class Store { } fun write(fileName: String, slices: List) { - val writer = PrintWriter(File(fileName)) - - writer.println("${slices.size}") - slices.forEach { slice -> - writer.println("${slice.startRow} ${slice.endRow} ${slice.startColumn} ${slice.endColumn}") + File("$fileName").printWriter().use { out -> + out.println("${slices.size}") + slices.forEach { slice -> + out.println("${slice.startRow} ${slice.startColumn} ${slice.endRow} ${slice.endColumn}") + } } }