Merge branch '71-game-of-life' into 'master'

Resolve "Game of life"

Closes #71

See merge request !58

.gitlab-ci.yml

@@ -23,3 +23,4 @@ include:
   - local: "/roman-calculator/.gitlab-ci.yml"
   - local: "/h2g2/.gitlab-ci.yml"
   - local: "/java-streams/.gitlab-ci.yml"
+  - local: "/game-of-life/.gitlab-ci.yml"

README.md

@@ -48,3 +48,4 @@ Ce dépôt Git a pour but de partager les différents ateliers pouvant être ré
 | [H2G2 (TypeScript)](/h2g2)                                                                                            | Kata        | Moyenne    |
 | [Java streams](/java-streams)                                                                                         | Code&coffee | Moyenne    |
 | [CodingGame Mars Landing Party](https://www.youtube.com/watch?v=FeJa3UnmeHw)                                          | CodingGame  | Moyenne    |
+| [Game of life](/game-of-life)                                                                                         | Kata        | Enervé     |

game-of-life/.gitlab-ci.yml

+package-game-of-life:
+  variables:
+    PROJECT_FOLDER: "game-of-life"
+  extends: .java
+  only:
+    refs:
+      - master
+      - merge_requests
+    changes:
+      - ".gitlab-common-ci.yml"
+      - "game-of-life/**/*"

game-of-life/README.md

+# Game of life
+
+Résolution en TDD et en Java du kata [Game of life](https://codingdojo.org/kata/GameOfLife/).
+
+-   **Auteurs** : Nicolas LE GRIEL et Colin DAMON
+-   **Date** : 20/01/2021
+-   **Langage** : Java
+-   **Niveau** : Enervé
+-   **Replay** : TODO

game-of-life/pom.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <version>1.0.0</version>
+    <groupId>fr.ippon.kata</groupId>
+    <artifactId>java-parent</artifactId>
+    <relativePath>../java-parent</relativePath>
+  </parent>
+
+  <version>1.0.0-SNAPSHOT</version>
+  <artifactId>game-of-life</artifactId>
+
+  <name>GameOfLife</name>
+
+  <developers>
+    <developer>
+      <email>nlegriel@ippon.fr</email>
+      <name>Nicolas LE GRIEL</name>
+    </developer>
+    <developer>
+      <email>cdamon@ippon.fr</email>
+      <name>Colin DAMON</name>
+    </developer>
+  </developers>
+</project>

game-of-life/src/main/java/fr/ippon/life/Cell.java

+package fr.ippon.life;
+
+import java.util.Set;
+
+public class Cell {
+  private static final int LOW_POPULATION_THRESHOLD = 2;
+  private static final int HIGH_POPULATION_THRESHOLD = 3;
+  private static final int BORN_THRESHOLD = HIGH_POPULATION_THRESHOLD;
+
+  private final int row;
+  private final int column;
+
+  public Cell(int row, int column) {
+    this.row = row;
+    this.column = column;
+  }
+
+  boolean stayAlive(Set<Cell> aliveCells) {
+    long neighbourgCount = countNeigbours(aliveCells);
+
+    return neighbourgCount == LOW_POPULATION_THRESHOLD || neighbourgCount == HIGH_POPULATION_THRESHOLD;
+  }
+
+  boolean born(Set<Cell> aliveCells) {
+    return countNeigbours(aliveCells) == BORN_THRESHOLD;
+  }
+
+  private long countNeigbours(Set<Cell> aliveCells) {
+    return aliveCells.stream().filter(this::isNeighbour).count();
+  }
+
+  private boolean isNeighbour(Cell other) {
+    if (other.equals(this)) {
+      return false;
+    }
+
+    return delta(row, other.row) <= 1 && delta(column, other.column) <= 1;
+  }
+
+  private static int delta(int first, int second) {
+    return Math.abs(first - second);
+  }
+
+  public int getRow() {
+    return row;
+  }
+
+  public int getColumn() {
+    return column;
+  }
+
+  @Override
+  public int hashCode() {
+    final int prime = 31;
+    int result = 1;
+    result = prime * result + column;
+    result = prime * result + row;
+    return result;
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (this == obj) return true;
+    if (obj == null) return false;
+    if (getClass() != obj.getClass()) return false;
+    Cell other = (Cell) obj;
+    if (column != other.column) return false;
+    if (row != other.row) return false;
+    return true;
+  }
+}

game-of-life/src/main/java/fr/ippon/life/Generation.java

+package fr.ippon.life;
+
+import java.util.Collection;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class Generation {
+  private Set<Cell> aliveCells;
+
+  public Generation(Cell... aliveCells) {
+    this(Set.of(aliveCells));
+  }
+
+  private Generation(Set<Cell> cells) {
+    aliveCells = cells;
+  }
+
+  public Generation next() {
+    Stream<Cell> stayAlive = aliveCells.stream().filter(cell -> cell.stayAlive(aliveCells));
+
+    Stream<Cell> born = buildGrid().deadCells().stream().filter(cell -> cell.born(aliveCells));
+
+    Set<Cell> cells = Stream.concat(stayAlive, born).collect(Collectors.toUnmodifiableSet());
+
+    return new Generation(cells);
+  }
+
+  public Collection<Cell> getAliveCells() {
+    return aliveCells;
+  }
+
+  private Grid buildGrid() {
+    return new Grid(aliveCells);
+  }
+}

game-of-life/src/main/java/fr/ippon/life/Grid.java

+package fr.ippon.life;
+
+import java.util.Collection;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+public class Grid {
+  private final Set<Cell> deadCells;
+  private final Box box;
+
+  Grid(Set<Cell> cells) {
+    box = new Box(cells);
+    this.deadCells = buildDeadCells(cells);
+  }
+
+  private Set<Cell> buildDeadCells(Set<Cell> cells) {
+    return IntStream
+      .range(box.getTopRow(), box.getBottomRow())
+      .mapToObj(Integer::valueOf)
+      .flatMap(row -> toDeadCell(cells, row))
+      .collect(Collectors.toUnmodifiableSet());
+  }
+
+  private Stream<Cell> toDeadCell(Set<Cell> cells, int row) {
+    return IntStream
+      .range(box.getLeftColumn(), box.getRightColumn())
+      .mapToObj(column -> new Cell(row, column))
+      .filter(cell -> !cells.contains(cell));
+  }
+
+  public Collection<Cell> deadCells() {
+    return deadCells;
+  }
+
+  private static class Box {
+    private final Point topLeft;
+    private final Point bottomRight;
+
+    public Box(Set<Cell> cells) {
+      topLeft = Point.topLeft(cells);
+      bottomRight = Point.bottomRight(cells);
+    }
+
+    public int getTopRow() {
+      return topLeft.getRow();
+    }
+
+    public int getBottomRow() {
+      return bottomRight.getRow() + 1;
+    }
+
+    public int getLeftColumn() {
+      return topLeft.getColumn();
+    }
+
+    public int getRightColumn() {
+      return bottomRight.getColumn() + 1;
+    }
+  }
+
+  private static class Point {
+    private final int row;
+    private final int column;
+
+    public Point(int row, int column) {
+      this.row = row;
+      this.column = column;
+    }
+
+    private static Point topLeft(Set<Cell> cells) {
+      int row = cells.stream().mapToInt(Cell::getRow).min().orElse(0);
+
+      int column = cells.stream().mapToInt(Cell::getColumn).min().orElse(0);
+
+      return new Point(row - 1, column - 1);
+    }
+
+    private static Point bottomRight(Set<Cell> cells) {
+      int row = cells.stream().mapToInt(Cell::getRow).max().orElse(0);
+
+      int column = cells.stream().mapToInt(Cell::getColumn).max().orElse(0);
+
+      return new Point(row + 1, column + 1);
+    }
+
+    public int getRow() {
+      return row;
+    }
+
+    public int getColumn() {
+      return column;
+    }
+  }
+}

game-of-life/src/test/java/fr/ippon/life/GameOfLifeTest.java

+package fr.ippon.life;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.jupiter.api.Test;
+
+class GameOfLifeTest {
+
+  @Test
+  void nextGenerationShouldHaveAllDeadCellsForAllDeadGrid() {
+    Generation nextGeneration = new Generation().next();
+
+    assertThat(nextGeneration.getAliveCells()).isEmpty();
+  }
+
+  @Test
+  void nextGenerationShouldHaveAllDeadCellsFromOneAliveCell() {
+    Generation nextGeneration = new Generation(cell(1, 1)).next();
+
+    assertThat(nextGeneration.getAliveCells()).isEmpty();
+  }
+
+  @Test
+  void nextGenerationShouldHaveAllDeadCellsFromTwoContiguousAliveCells() {
+    Generation nextGeneration = new Generation(cell(1, 1), cell(2, 1)).next();
+
+    assertThat(nextGeneration.getAliveCells()).isEmpty();
+  }
+
+  @Test
+  void nextGenerationShouldHaveFourAliveCellsFromTriangularConfiguration() {
+    Cell first = cell(1, 2);
+    Cell second = cell(2, 1);
+    Cell third = cell(2, 2);
+    Generation nextGeneration = new Generation(first, second, third).next();
+
+    assertThat(nextGeneration.getAliveCells()).containsExactlyInAnyOrder(cell(1, 1), first, second, third);
+  }
+
+  @Test
+  void nextGenerationShouldHaveOneColumnFromOneLine() {
+    Generation nextGeneration = new Generation(cell(4, 5), cell(5, 5), cell(6, 5)).next();
+
+    assertThat(nextGeneration.getAliveCells()).containsExactlyInAnyOrder(cell(5, 4), cell(5, 5), cell(5, 6));
+  }
+
+  @Test
+  void shouldAdvanceInGenerations() {
+    Generation nextGeneration = threeCellsColumn();
+
+    assertThat(nextGeneration.getAliveCells()).containsExactlyInAnyOrder(cell(4, 5), cell(5, 5), cell(6, 5));
+  }
+
+  private Generation threeCellsColumn() {
+    return new Generation(cell(4, 5), cell(5, 5), cell(6, 5)).next().next();
+  }
+
+  private static Cell cell(int row, int column) {
+    return new Cell(row, column);
+  }
+}