Skip to content

Commit

Permalink
Day 07 - WIP, refactored
Browse files Browse the repository at this point in the history
  • Loading branch information
@kocmana
kocmana committed Dec 22, 2023
1 parent 3b729cc commit ba2b935
Show file tree
Hide file tree
Showing 5 changed files with 119 additions and 57 deletions.
3 changes: 3 additions & 0 deletions src/main/java/at/kocmana/aoc23/common/Triple.java
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,3 @@
package at.kocmana.aoc23.common;

public record Triple<T, U, V>(T first, U second, V third) {}
2 changes: 1 addition & 1 deletion src/main/java/at/kocmana/aoc23/common/Tuple.java
View file
Original file line number Diff line number Diff line change
@@ -1,4 +1,4 @@
package at.kocmana.aoc23.common;

public record Tuple<T,U>(T value, U key) {
public record Tuple<T,U>(T key, U value) {
}
1 change: 1 addition & 0 deletions src/main/java/at/kocmana/aoc23/dec07/Power.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -13,6 +13,7 @@ public int compareTo(Power other) {
return this.type.compareTo(other.type);
}
return IntStream.range(0, relevantCards.size())
.sequential()
.map(i -> this.relevantCards.get(i).compareTo(other.relevantCards.get(i)))
.filter(comparison -> comparison != 0)
.findFirst()
Expand Down
62 changes: 21 additions & 41 deletions src/main/java/at/kocmana/aoc23/dec07/PowerFactory.java
View file
Original file line number Diff line number Diff line change
@@ -1,6 +1,5 @@
package at.kocmana.aoc23.dec07;

import static java.util.Collections.singletonList;
import static java.util.stream.Collectors.counting;
import static java.util.stream.Collectors.groupingBy;

Expand All @@ -11,61 +10,42 @@

class PowerFactory {

private static final Map<List<Integer>, Type> TYPE_DICTIONARY = Map.of(
List.of(5), Type.FIVE_OF_A_KIND,
List.of(4, 1), Type.FOUR_OF_A_KIND,
List.of(3, 2), Type.FULL_HOUSE,
List.of(3, 1, 1), Type.THREE_OF_A_KIND,
List.of(2, 2, 1), Type.TWO_PAIR,
List.of(2, 1, 1, 1), Type.ONE_PAIR,
List.of(1, 1, 1, 1, 1), Type.HIGH_CARD
);

private PowerFactory() {
}

static Power fromCards(List<Card> cardList) {
var amountOfCardsByLabel = cardList.stream()
.collect(groupingBy(Function.identity(), counting()));


Comparator<Map.Entry<Card, Long>> frequencyThenCardLabel =
Map.Entry.<Card, Long>comparingByValue().reversed()
.thenComparing(Map.Entry.<Card, Long>comparingByKey());

var sortedAmounts = amountOfCardsByLabel.entrySet().stream()
.sorted(frequencyThenCardLabel)
.toList();
var sortedValues = sortedAmounts.stream()
.map(e -> e.getValue().intValue())
.toList();
var sortedCards = sortedAmounts.stream()
.map(Map.Entry::getKey)
.toList();

var firstEntry = sortedAmounts.get(0);
if (firstEntry.getValue() == 5) {
return new Power(
Type.FIVE_OF_A_KIND,
singletonList(firstEntry.getKey())
);
}
var secondEntry = sortedAmounts.get(1);
if (firstEntry.getValue() == 4) {
return new Power(
Type.FOUR_OF_A_KIND,
singletonList(firstEntry.getKey())
);
} else if (firstEntry.getValue() == 3 && secondEntry.getValue() == 2) {
return new Power(
Type.FULL_HOUSE,
List.of(firstEntry.getKey(), secondEntry.getKey())
);
} else if (firstEntry.getValue() == 3) {
return new Power(
Type.THREE_OF_A_KIND,
singletonList(firstEntry.getKey())
);
} else if (firstEntry.getValue() == 2 && secondEntry.getValue() == 2) {
return new Power(
Type.TWO_PAIR,
List.of(firstEntry.getKey(), secondEntry.getKey())
);
} else if (firstEntry.getValue() == 2) {
return new Power(
Type.ONE_PAIR,
singletonList(firstEntry.getKey())
);
} else {
return new Power(
Type.HIGH_CARD,
cardList
);
}
var type = TYPE_DICTIONARY.get(sortedValues);
return new Power(
type,
sortedCards
);
}
}

108 changes: 93 additions & 15 deletions src/test/java/at/kocmana/aoc23/dec07/CamelCardsTest.java
View file
Original file line number Diff line number Diff line change
@@ -1,9 +1,9 @@
package at.kocmana.aoc23.dec07;

import static java.util.Collections.singletonList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.from;

import at.kocmana.aoc23.common.Triple;
import at.kocmana.aoc23.common.Tuple;
import java.util.List;
import java.util.stream.Stream;
Expand All @@ -14,6 +14,25 @@
class CamelCardsTest {


static Stream<Tuple<Hand, Power>> generateCanAssessPowerTestValues() {
return Stream.of(
new Tuple<>(new Hand(List.of(Card.ACE, Card.ACE, Card.ACE, Card.ACE, Card.ACE), 1),
new Power(Type.FIVE_OF_A_KIND, List.of(Card.ACE))),
new Tuple<>(new Hand(List.of(Card.THREE, Card.THREE, Card.THREE, Card.THREE, Card.TWO), 1),
new Power(Type.FOUR_OF_A_KIND, List.of(Card.THREE, Card.TWO))),
new Tuple<>(new Hand(List.of(Card.ACE, Card.ACE, Card.ACE, Card.TWO, Card.TWO), 1),
new Power(Type.FULL_HOUSE, List.of(Card.ACE, Card.TWO))),
new Tuple<>(new Hand(List.of(Card.ACE, Card.ACE, Card.ACE, Card.TWO, Card.THREE), 1),
new Power(Type.THREE_OF_A_KIND, List.of(Card.ACE, Card.THREE, Card.TWO))),
new Tuple<>(new Hand(List.of(Card.ACE, Card.ACE, Card.TWO, Card.TWO, Card.THREE), 1),
new Power(Type.TWO_PAIR, List.of(Card.ACE, Card.TWO, Card.THREE))),
new Tuple<>(new Hand(List.of(Card.ACE, Card.ACE, Card.TWO, Card.THREE, Card.FOUR), 1),
new Power(Type.ONE_PAIR, List.of(Card.ACE, Card.FOUR, Card.THREE, Card.TWO))),
new Tuple<>(new Hand(List.of(Card.ACE, Card.SIX, Card.THREE, Card.FOUR, Card.FIVE), 1),
new Power(Type.HIGH_CARD, List.of(Card.ACE, Card.SIX, Card.FIVE, Card.FOUR, Card.THREE)))
);
}

@Test
void canBeParsed() {
//given
Expand All @@ -36,28 +55,56 @@ void canBeParsed() {
);
}

static Stream<Tuple<Hand, Power>> generateCanAssessPowerTestValues(){
@ParameterizedTest
@MethodSource("generateCanAssessPowerTestValues")
void canAssessPower(Tuple<Hand, Power> testValue) {
//when
var actualResult = PowerFactory.fromCards(testValue.key().cards());

//then
assertThat(actualResult).isNotNull()
.returns(testValue.value().type(), from(Power::type))
.returns(testValue.value().relevantCards(), from(Power::relevantCards));
}

static Stream<Triple<Power, Power, Integer>> generateCanComparePowerTestValues() {
return Stream.of(
//new Tuple<>(new Hand(List.of(Card.ACE, Card.ACE, Card.ACE, Card.ACE, Card.ACE), 1), new Result(Type.FIVE_OF_A_KIND, singletonList(Card.ACE))),
new Tuple<>(new Hand(List.of(Card.ACE, Card.ACE, Card.ACE, Card.ACE, Card.TWO), 1), new Power(Type.FOUR_OF_A_KIND, singletonList(Card.ACE))),
new Tuple<>(new Hand(List.of(Card.ACE, Card.ACE, Card.ACE, Card.TWO, Card.TWO), 1), new Power(Type.FULL_HOUSE, List.of(Card.ACE, Card.TWO))),
new Tuple<>(new Hand(List.of(Card.ACE, Card.ACE, Card.ACE, Card.TWO, Card.THREE), 1), new Power(Type.THREE_OF_A_KIND, singletonList(Card.ACE))),
new Tuple<>(new Hand(List.of(Card.ACE, Card.ACE, Card.TWO, Card.TWO, Card.THREE), 1), new Power(Type.TWO_PAIR, List.of(Card.ACE, Card.TWO))),
new Tuple<>(new Hand(List.of(Card.ACE, Card.ACE, Card.TWO, Card.THREE, Card.FOUR), 1), new Power(Type.ONE_PAIR, List.of(Card.ACE))),
new Tuple<>(new Hand(List.of(Card.ACE, Card.TWO, Card.THREE, Card.FOUR, Card.FIVE), 1), new Power(Type.HIGH_CARD, List.of(Card.ACE, Card.TWO, Card.THREE, Card.FOUR, Card.FIVE)))
new Triple(
new Power(Type.HIGH_CARD, List.of(Card.ACE, Card.KING, Card.QUEEN, Card.THREE, Card.TWO)),
new Power(Type.HIGH_CARD, List.of(Card.KING, Card.QUEEN, Card.JACK, Card.TEN, Card.NINE)),
-1
),
new Triple(
new Power(Type.HIGH_CARD, List.of(Card.ACE, Card.QUEEN, Card.JACK, Card.TEN, Card.NINE)),
new Power(Type.HIGH_CARD, List.of(Card.ACE, Card.KING, Card.QUEEN, Card.THREE, Card.TWO)),
1
),
new Triple(
new Power(Type.FOUR_OF_A_KIND, List.of(Card.FOUR, Card.FOUR, Card.FOUR, Card.FOUR, Card.NINE)),
new Power(Type.FOUR_OF_A_KIND, List.of(Card.THREE, Card.THREE, Card.THREE, Card.THREE, Card.ACE)),
-1
),
new Triple(
new Power(Type.FIVE_OF_A_KIND, List.of(Card.FOUR, Card.FOUR, Card.FOUR, Card.FOUR, Card.FOUR)),
new Power(Type.TWO_PAIR, List.of(Card.THREE, Card.THREE, Card.FOUR, Card.FOUR, Card.ACE)),
-4
)
);
}

@ParameterizedTest
@MethodSource("generateCanAssessPowerTestValues")
void canAssessPower(Tuple<Hand, Power> testValue) {
@MethodSource("generateCanComparePowerTestValues")
void canComparePowers(Triple<Power, Power, Integer> testData) {
//given
var left = testData.first();
var right = testData.second();
var expectedResult = testData.third();

//when
var actualResult = testValue.value().power();
var actualResult = left.compareTo(right);

//then
assertThat(actualResult).isNotNull()
.returns(testValue.key().type(), from(Power::type))
.returns(testValue.key().relevantCards(), from(Power::relevantCards));
assertThat(actualResult).isEqualTo(expectedResult);
}

@Test
Expand All @@ -78,4 +125,35 @@ void canIntegrate() {
assertThat(actualResult).isEqualTo(6440L);
}

@Test
void canSortHands() {
//given
var fifth = new Hand(List.of(Card.THREE, Card.THREE, Card.THREE, Card.THREE, Card.THREE), 0);
var fourth = new Hand(List.of(Card.FOUR, Card.FOUR, Card.FOUR, Card.FOUR, Card.THREE), 0);
var third = new Hand(List.of(Card.KING, Card.KING, Card.FOUR, Card.FOUR, Card.THREE), 0);
var second = new Hand(List.of(Card.KING, Card.KING, Card.THREE, Card.THREE, Card.ACE), 0);
var first = new Hand(List.of(Card.KING, Card.ACE, Card.THREE, Card.NINE, Card.EIGHT), 0);

var unsortedHands = List.of(
second,
fourth,
fifth,
first,
third
);

//when
var actualResult = CamelCards.sortLists(unsortedHands);

//then
assertThat(actualResult).hasSize(5)
.containsExactly(
first,
second,
third,
fourth,
fifth
);
}

}

0 comments on commit ba2b935

Please sign in to comment.