diff --git a/src/main/java/io/takima/Yatzy.java b/src/main/java/io/takima/Yatzy.java
index 04d59cad749de10f9afe70ab0d13bda33d495a84..b240a0f26030d1cfb040d27f84919bb6ee9e1b73 100644
--- a/src/main/java/io/takima/Yatzy.java
+++ b/src/main/java/io/takima/Yatzy.java
@@ -1,16 +1,10 @@
package io.takima;
-public class Yatzy {
+public final class Yatzy {
+ private final int[] dice;
- protected int[] dice;
-
- public Yatzy(int d1, int d2, int d3, int d4, int _5) {
- dice = new int[5];
- dice[0] = d1;
- dice[1] = d2;
- dice[2] = d3;
- dice[3] = d4;
- dice[4] = _5;
+ public Yatzy(int d1, int d2, int d3, int d4, int d5) {
+ dice = new int[] { d1, d2, d3, d4, d5 };
}
public static int chance(int d1, int d2, int d3, int d4, int d5) {
@@ -25,62 +19,94 @@ public class Yatzy {
public static int yatzy(int... dice) {
int[] counts = new int[6];
- for (int die : dice)
+ for (int die : dice) {
counts[die - 1]++;
- for (int i = 0; i != 6; i++)
- if (counts[i] == 5)
+ }
+ for (int i = 0; i != 6; i++) {
+ if (counts[i] == 5) {
return 50;
+ }
+ }
return 0;
}
public static int ones(int d1, int d2, int d3, int d4, int d5) {
int sum = 0;
- if (d1 == 1) sum++;
- if (d2 == 1) sum++;
- if (d3 == 1) sum++;
- if (d4 == 1) sum++;
- if (d5 == 1)
+ if (d1 == 1) {
+ sum++;
+ }
+ if (d2 == 1) {
+ sum++;
+ }
+ if (d3 == 1) {
+ sum++;
+ }
+ if (d4 == 1) {
sum++;
+ }
+ if (d5 == 1) {
+ sum++;
+ }
return sum;
}
public static int twos(int d1, int d2, int d3, int d4, int d5) {
int sum = 0;
- if (d1 == 2) sum += 2;
- if (d2 == 2) sum += 2;
- if (d3 == 2) sum += 2;
- if (d4 == 2) sum += 2;
- if (d5 == 2) sum += 2;
+ if (d1 == 2) {
+ sum += 2;
+ }
+ if (d2 == 2) {
+ sum += 2;
+ }
+ if (d3 == 2) {
+ sum += 2;
+ }
+ if (d4 == 2) {
+ sum += 2;
+ }
+ if (d5 == 2) {
+ sum += 2;
+ }
return sum;
}
public static int threes(int d1, int d2, int d3, int d4, int d5) {
- int s;
- s = 0;
- if (d1 == 3) s += 3;
- if (d2 == 3) s += 3;
- if (d3 == 3) s += 3;
- if (d4 == 3) s += 3;
- if (d5 == 3) s += 3;
+ int s = 0;
+ if (d1 == 3) {
+ s += 3;
+ }
+ if (d2 == 3) {
+ s += 3;
+ }
+ if (d3 == 3) {
+ s += 3;
+ }
+ if (d4 == 3) {
+ s += 3;
+ }
+ if (d5 == 3) {
+ s += 3;
+ }
return s;
}
- public static int score_pair(int d1, int d2, int d3, int d4, int d5) {
+ public static int pair(int d1, int d2, int d3, int d4, int d5) {
int[] counts = new int[6];
counts[d1 - 1]++;
counts[d2 - 1]++;
counts[d3 - 1]++;
counts[d4 - 1]++;
counts[d5 - 1]++;
- int at;
- for (at = 0; at != 6; at++)
- if (counts[6 - at - 1] >= 2)
+ for (int at = 0; at != 6; at++) {
+ if (counts[6 - at - 1] >= 2) {
return (6 - at) * 2;
+ }
+ }
return 0;
}
- public static int two_pair(int d1, int d2, int d3, int d4, int d5) {
+ public static int twoPair(int d1, int d2, int d3, int d4, int d5) {
int[] counts = new int[6];
counts[d1 - 1]++;
counts[d2 - 1]++;
@@ -89,116 +115,121 @@ public class Yatzy {
counts[d5 - 1]++;
int n = 0;
int score = 0;
- for (int i = 0; i < 6; i += 1)
+ for (int i = 0; i < 6; i += 1) {
if (counts[6 - i - 1] >= 2) {
n++;
score += (6 - i);
}
- if (n == 2)
+ }
+ if (n == 2) {
return score * 2;
- else
+ } else {
return 0;
+ }
}
- public static int four_of_a_kind(int _1, int _2, int d3, int d4, int d5) {
- int[] tallies;
- tallies = new int[6];
- tallies[_1 - 1]++;
- tallies[_2 - 1]++;
- tallies[d3 - 1]++;
- tallies[d4 - 1]++;
- tallies[d5 - 1]++;
- for (int i = 0; i < 6; i++)
- if (tallies[i] >= 4)
+ public static int fourOfAKind(int d1, int d2, int d3, int d4, int d5) {
+ int[] counts;
+ counts = new int[6];
+ counts[d1 - 1]++;
+ counts[d2 - 1]++;
+ counts[d3 - 1]++;
+ counts[d4 - 1]++;
+ counts[d5 - 1]++;
+ for (int i = 0; i < 6; i++) {
+ if (counts[i] >= 4) {
return (i + 1) * 4;
+ }
+ }
return 0;
}
- public static int three_of_a_kind(int d1, int d2, int d3, int d4, int d5) {
- int[] t;
- t = new int[6];
- t[d1 - 1]++;
- t[d2 - 1]++;
- t[d3 - 1]++;
- t[d4 - 1]++;
- t[d5 - 1]++;
- for (int i = 0; i < 6; i++)
- if (t[i] >= 3)
+ public static int threeOfAKind(int d1, int d2, int d3, int d4, int d5) {
+ int[] counts;
+ counts = new int[6];
+ counts[d1 - 1]++;
+ counts[d2 - 1]++;
+ counts[d3 - 1]++;
+ counts[d4 - 1]++;
+ counts[d5 - 1]++;
+ for (int i = 0; i < 6; i++) {
+ if (counts[i] >= 3) {
return (i + 1) * 3;
+ }
+ }
return 0;
}
public static int smallStraight(int d1, int d2, int d3, int d4, int d5) {
- int[] tallies;
- tallies = new int[6];
- tallies[d1 - 1] += 1;
- tallies[d2 - 1] += 1;
- tallies[d3 - 1] += 1;
- tallies[d4 - 1] += 1;
- tallies[d5 - 1] += 1;
- if (tallies[0] == 1 &&
- tallies[1] == 1 &&
- tallies[2] == 1 &&
- tallies[3] == 1 &&
- tallies[4] == 1)
+ int[] counts;
+ counts = new int[6];
+ counts[d1 - 1] += 1;
+ counts[d2 - 1] += 1;
+ counts[d3 - 1] += 1;
+ counts[d4 - 1] += 1;
+ counts[d5 - 1] += 1;
+ if (counts[0] == 1 &&
+ counts[1] == 1 &&
+ counts[2] == 1 &&
+ counts[3] == 1 &&
+ counts[4] == 1) {
return 15;
+ }
return 0;
}
public static int largeStraight(int d1, int d2, int d3, int d4, int d5) {
- int[] tallies;
- tallies = new int[6];
- tallies[d1 - 1] += 1;
- tallies[d2 - 1] += 1;
- tallies[d3 - 1] += 1;
- tallies[d4 - 1] += 1;
- tallies[d5 - 1] += 1;
- if (tallies[1] == 1 &&
- tallies[2] == 1 &&
- tallies[3] == 1 &&
- tallies[4] == 1
- && tallies[5] == 1)
+ int[] counts;
+ counts = new int[6];
+ counts[d1 - 1] += 1;
+ counts[d2 - 1] += 1;
+ counts[d3 - 1] += 1;
+ counts[d4 - 1] += 1;
+ counts[d5 - 1] += 1;
+ if (counts[1] == 1 &&
+ counts[2] == 1 &&
+ counts[3] == 1 &&
+ counts[4] == 1
+ && counts[5] == 1) {
return 20;
+ }
return 0;
}
public static int fullHouse(int d1, int d2, int d3, int d4, int d5) {
- int[] tallies;
- boolean _2 = false;
- int i;
- int _2_at = 0;
- boolean _3 = false;
- int _3_at = 0;
-
-
- tallies = new int[6];
- tallies[d1 - 1] += 1;
- tallies[d2 - 1] += 1;
- tallies[d3 - 1] += 1;
- tallies[d4 - 1] += 1;
- tallies[d5 - 1] += 1;
-
- for (i = 0; i != 6; i += 1)
- if (tallies[i] == 2) {
- _2 = true;
- _2_at = i + 1;
+ boolean hasPair = false;
+ int pairValue = 0;
+ boolean hasTriplet = false;
+ int tripletValue = 0;
+
+
+ int[] counts = new int[6];
+ counts[d1 - 1] += 1;
+ counts[d2 - 1] += 1;
+ counts[d3 - 1] += 1;
+ counts[d4 - 1] += 1;
+ counts[d5 - 1] += 1;
+
+ for (int i = 0; i != 6; i += 1)
+ if (counts[i] == 2) {
+ hasPair = true;
+ pairValue = i + 1;
}
- for (i = 0; i != 6; i += 1)
- if (tallies[i] == 3) {
- _3 = true;
- _3_at = i + 1;
+ for (int i = 0; i != 6; i += 1)
+ if (counts[i] == 3) {
+ hasTriplet = true;
+ tripletValue = i + 1;
}
- if (_2 && _3)
- return _2_at * 2 + _3_at * 3;
+ if (hasPair && hasTriplet)
+ return pairValue * 2 + tripletValue * 3;
else
return 0;
}
public int fours() {
- int sum;
- sum = 0;
+ int sum = 0;
for (int at = 0; at != 5; at++) {
if (dice[at] == 4) {
sum += 4;
@@ -209,18 +240,21 @@ public class Yatzy {
public int fives() {
int s = 0;
- int i;
- for (i = 0; i < dice.length; i++)
- if (dice[i] == 5)
- s = s + 5;
+ for (int i = 0; i < dice.length; i++) {
+ if (dice[i] == 5) {
+ s += 5;
+ }
+ }
return s;
}
public int sixes() {
int sum = 0;
- for (int at = 0; at < dice.length; at++)
- if (dice[at] == 6)
+ for (int at = 0; at < dice.length; at++) {
+ if (dice[at] == 6) {
sum = sum + 6;
+ }
+ }
return sum;
}
}
diff --git a/src/test/java/io/takima/YatzyTest.java b/src/test/java/io/takima/YatzyTest.java
index a8f32145a9e7a543cdf37f35236df54b9e95ac2b..75539a722c7b1b1c6b158a5a02c3234b00b155e1 100644
--- a/src/test/java/io/takima/YatzyTest.java
+++ b/src/test/java/io/takima/YatzyTest.java
@@ -2,113 +2,173 @@ package io.takima;
import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
class YatzyTest {
+ @Test
+ void chanceShouldSumAllDices() {
+ assertAll(
+ () -> assertEquals(15, Yatzy.chance(2, 3, 4, 5, 1)),
+ () -> assertEquals(16, Yatzy.chance(3, 3, 4, 5, 1))
+ );
+ }
@Test
- void chance_scores_sum_of_all_dice() {
- int expected = 15;
- int actual = Yatzy.chance(2, 3, 4, 5, 1);
- assertEquals(expected, actual);
- assertEquals(16, Yatzy.chance(3, 3, 4, 5, 1));
+ void yatzyShouldScoreFiftyIfAllDicesHaveTheSameValue() {
+ assertAll(
+ () -> assertEquals(50, Yatzy.yatzy(4, 4, 4, 4, 4)),
+ () -> assertEquals(50, Yatzy.yatzy(6, 6, 6, 6, 6))
+ );
}
@Test
- void yatzy_scores_50() {
- int expected = 50;
- int actual = Yatzy.yatzy(4, 4, 4, 4, 4);
- assertEquals(expected, actual);
- assertEquals(50, Yatzy.yatzy(6, 6, 6, 6, 6));
+ void yatzyShouldScoreZeroIfAllDicesHaveNotTheSameValue() {
assertEquals(0, Yatzy.yatzy(6, 6, 6, 6, 3));
}
@Test
- void test_1s() {
- assertTrue(Yatzy.ones(1, 2, 3, 4, 5) == 1);
- assertEquals(2, Yatzy.ones(1, 2, 1, 4, 5));
- assertEquals(0, Yatzy.ones(6, 2, 2, 4, 5));
- assertEquals(4, Yatzy.ones(1, 2, 1, 1, 1));
+ void onesShouldSumAllOneDices() {
+ assertAll(
+ () -> assertEquals(1, Yatzy.ones(1, 2, 3, 4, 5)),
+ () -> assertEquals(2, Yatzy.ones(1, 2, 1, 4, 5)),
+ () -> assertEquals(0, Yatzy.ones(6, 2, 2, 4, 5)),
+ () -> assertEquals(4, Yatzy.ones(1, 2, 1, 1, 1))
+ );
+ }
+
+ @Test
+ void twosShouldSumAllTwoDices() {
+ assertAll(
+ () -> assertEquals(4, Yatzy.twos(1, 2, 3, 2, 6)),
+ () -> assertEquals(10, Yatzy.twos(2, 2, 2, 2, 2))
+ );
+ }
+
+ @Test
+ void threesShouldSumAllThreeDices() {
+ assertAll(
+ () -> assertEquals(6, Yatzy.threes(1, 2, 3, 2, 3)),
+ () -> assertEquals(12, Yatzy.threes(2, 3, 3, 3, 3))
+ );
+ }
+
+ @Test
+ void foursShouldSumAllFourDices() {
+ assertAll(
+ () -> assertEquals(12, new Yatzy(4, 4, 4, 5, 5).fours()),
+ () -> assertEquals(8, new Yatzy(4, 4, 5, 5, 5).fours()),
+ () -> assertEquals(4, new Yatzy(4, 5, 5, 5, 5).fours())
+ );
+ }
+
+ @Test
+ void fivesShouldSumAllFiveDices() {
+ assertAll(
+ () -> assertEquals(10, new Yatzy(4, 4, 4, 5, 5).fives()),
+ () -> assertEquals(15, new Yatzy(4, 4, 5, 5, 5).fives()),
+ () -> assertEquals(20, new Yatzy(4, 5, 5, 5, 5).fives())
+ );
+ }
+
+ @Test
+ void sixesShouldSumAllSixDices() {
+ assertAll(
+ () -> assertEquals(0, new Yatzy(4, 4, 4, 5, 5).sixes()),
+ () -> assertEquals(6, new Yatzy(4, 4, 6, 5, 5).sixes()),
+ () -> assertEquals(18, new Yatzy(6, 5, 6, 6, 5).sixes())
+ );
}
@Test
- void test_2s() {
- assertEquals(4, Yatzy.twos(1, 2, 3, 2, 6));
- assertEquals(10, Yatzy.twos(2, 2, 2, 2, 2));
+ void pairShouldSumTheTwoHighestMatchingPair() {
+ assertAll(
+ () -> assertEquals(6, Yatzy.pair(3, 4, 3, 5, 6)),
+ () -> assertEquals(10, Yatzy.pair(5, 3, 3, 3, 5)),
+ () -> assertEquals(12, Yatzy.pair(5, 3, 6, 6, 5))
+ );
}
@Test
- void test_threes() {
- assertEquals(6, Yatzy.threes(1, 2, 3, 2, 3));
- assertEquals(12, Yatzy.threes(2, 3, 3, 3, 3));
+ void twoPairShouldSumTheScoreOfAllDiceWhichMatchWithDistinctPair() {
+ assertAll(
+ () -> assertEquals(16, Yatzy.twoPair(3, 3, 5, 4, 5)),
+ () -> assertEquals(16, Yatzy.twoPair(3, 3, 5, 5, 5))
+ );
}
@Test
- void fours_test() {
- assertEquals(12, new Yatzy(4, 4, 4, 5, 5).fours());
- assertEquals(8, new Yatzy(4, 4, 5, 5, 5).fours());
- assertEquals(4, new Yatzy(4, 5, 5, 5, 5).fours());
+ void twoPairShouldMatchIfThereIsTwoDistinctPair() {
+ assertEquals(0, Yatzy.twoPair(3, 3, 3, 3, 1));
}
@Test
- void fives() {
- assertEquals(10, new Yatzy(4, 4, 4, 5, 5).fives());
- assertEquals(15, new Yatzy(4, 4, 5, 5, 5).fives());
- assertEquals(20, new Yatzy(4, 5, 5, 5, 5).fives());
+ void threeOfAKindShouldSumTheThreeDiceWithTheSameValue() {
+ assertAll(
+ () -> assertEquals(9, Yatzy.threeOfAKind(3, 3, 3, 4, 5)),
+ () -> assertEquals(15, Yatzy.threeOfAKind(5, 3, 5, 4, 5)),
+ () -> assertEquals(9, Yatzy.threeOfAKind(3, 3, 3, 3, 5))
+ );
}
@Test
- void sixes_test() {
- assertEquals(0, new Yatzy(4, 4, 4, 5, 5).sixes());
- assertEquals(6, new Yatzy(4, 4, 6, 5, 5).sixes());
- assertEquals(18, new Yatzy(6, 5, 6, 6, 5).sixes());
+ void threeOfAKindShouldReturnZeroIfThereIsNoThreeDiceWithTheSameValue() {
+ assertEquals(0, Yatzy.threeOfAKind(3, 3, 4, 5, 6));
}
@Test
- void one_pair() {
- assertEquals(6, Yatzy.score_pair(3, 4, 3, 5, 6));
- assertEquals(10, Yatzy.score_pair(5, 3, 3, 3, 5));
- assertEquals(12, Yatzy.score_pair(5, 3, 6, 6, 5));
+ void fourOfAKindShouldSumTheFourDiceWithTheSameValue() {
+ assertAll(
+ () -> assertEquals(12, Yatzy.fourOfAKind(3, 3, 3, 3, 5)),
+ () -> assertEquals(20, Yatzy.fourOfAKind(5, 5, 5, 4, 5)),
+ () -> assertEquals(9, Yatzy.threeOfAKind(3, 3, 3, 3, 3))
+ );
}
@Test
- void two_Pair() {
- assertEquals(16, Yatzy.two_pair(3, 3, 5, 4, 5));
- assertEquals(16, Yatzy.two_pair(3, 3, 5, 5, 5));
+ void fourOfAKindShouldReturnZeroIfThereIsNoFourDiceWithTheSameValue() {
+ assertEquals(0, Yatzy.fourOfAKind(2, 2, 2, 5, 5));
}
@Test
- void three_of_a_kind() {
- assertEquals(9, Yatzy.three_of_a_kind(3, 3, 3, 4, 5));
- assertEquals(15, Yatzy.three_of_a_kind(5, 3, 5, 4, 5));
- assertEquals(9, Yatzy.three_of_a_kind(3, 3, 3, 3, 5));
+ void smallStraightShouldReturnFifteenIfDiceAreFromOneToFive() {
+ assertAll(
+ () -> assertEquals(15, Yatzy.smallStraight(1, 2, 3, 4, 5)),
+ () -> assertEquals(15, Yatzy.smallStraight(2, 3, 4, 5, 1))
+ );
}
@Test
- void four_of_a_knd() {
- assertEquals(12, Yatzy.four_of_a_kind(3, 3, 3, 3, 5));
- assertEquals(20, Yatzy.four_of_a_kind(5, 5, 5, 4, 5));
- assertEquals(9, Yatzy.three_of_a_kind(3, 3, 3, 3, 3));
+ void smallStraightShouldReturnZeroIfDicesAreNotFromOneToFive() {
+ assertAll(
+ () -> assertEquals(0, Yatzy.smallStraight(1, 2, 2, 4, 5)),
+ () -> assertEquals(0, Yatzy.smallStraight(2, 3, 4, 5, 6))
+ );
}
@Test
- void smallStraight() {
- assertEquals(15, Yatzy.smallStraight(1, 2, 3, 4, 5));
- assertEquals(15, Yatzy.smallStraight(2, 3, 4, 5, 1));
- assertEquals(0, Yatzy.smallStraight(1, 2, 2, 4, 5));
+ void largeStraightShouldReturnTwentyIfDicesAreFromTwoToSix() {
+ assertAll(
+ () -> assertEquals(20, Yatzy.largeStraight(6, 2, 3, 4, 5)),
+ () -> assertEquals(20, Yatzy.largeStraight(2, 3, 4, 5, 6))
+ );
}
@Test
- void largeStraight() {
- assertEquals(20, Yatzy.largeStraight(6, 2, 3, 4, 5));
- assertEquals(20, Yatzy.largeStraight(2, 3, 4, 5, 6));
- assertEquals(0, Yatzy.largeStraight(1, 2, 2, 4, 5));
+ void largeStraightShouldReturnZeroIfDicesAreNotFromTwoToSix() {
+ assertAll(
+ () -> assertEquals(0, Yatzy.largeStraight(1, 2, 2, 4, 5)),
+ () -> assertEquals(0, Yatzy.largeStraight(2, 4, 6, 5, 1))
+ );
}
@Test
- void fullHouse() {
+ void fullHouseShouldSumDicesIfThereAreATripletAndAPair() {
assertEquals(18, Yatzy.fullHouse(6, 2, 2, 2, 6));
+ }
+
+ @Test
+ void fullHouseShouldReturnZeroIfThereIsNotTripletAndPair() {
assertEquals(0, Yatzy.fullHouse(2, 3, 4, 5, 6));
}
}