Skip to content

Commit b7f477e

Browse files
pareroniapareronia
committed
java - java17
1 parent 58df4cb commit b7f477e

File tree

2 files changed

+100
-96
lines changed

2 files changed

+100
-96
lines changed

‎src/main/java/AoC2020_14.java

Lines changed: 42 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -3,27 +3,21 @@
33
import java.util.ArrayList;
44
import java.util.HashMap;
55
import java.util.List;
6-
import java.util.Map;
76
import java.util.stream.IntStream;
87

98
import org.apache.commons.lang3.StringUtils;
109

1110
import com.github.pareronia.aocd.Aocd;
1211
import com.github.pareronia.aocd.Puzzle;
1312

14-
import lombok.Builder;
15-
import lombok.RequiredArgsConstructor;
16-
import lombok.Singular;
17-
import lombok.ToString;
18-
1913
public class AoC2020_14 extends AoCBase {
2014

2115
private final List<Group> groups;
2216

2317
private AoC2020_14(final List<String> input, final boolean debug) {
2418
super(debug);
2519
this.groups = new ArrayList<>();
26-
Group.GroupBuilder groupBuilder = Group.builder();
20+
var groupBuilder = Group.builder();
2721
groupBuilder.mask(input.get(0).substring("mask = ".length()));
2822
for (int i = 1; i <= input.size(); i++) {
2923
if (i == input.size()) {
@@ -33,7 +27,7 @@ private AoC2020_14(final List<String> input, final boolean debug) {
3327
groupBuilder = Group.builder();
3428
groupBuilder.mask(input.get(i).substring("mask = ".length()));
3529
} else {
36-
final String[] splits = input.get(i).split("] = ");
30+
final var splits = input.get(i).split("] = ");
3731
final int address = Integer.parseInt(splits[0].substring("mem[".length()));
3832
final int value = Integer.parseInt(splits[1]);
3933
groupBuilder.write(new Write(address, value));
@@ -89,10 +83,10 @@ private Result applyMask2(final long address, final long value, final String mas
8983
}
9084

9185
private Long solve(final Strategy strategy) {
92-
final Map<String, Long> memory = new HashMap<>();
93-
for (final Group group : this.groups) {
94-
for (final Write write : group.writes) {
95-
final Result result = strategy.execute(write.address, write.value, group.mask);
86+
final var memory = new HashMap<String, Long>();
87+
for (final var group : this.groups) {
88+
for (final var write : group.writes) {
89+
final var result = strategy.execute(write.address, write.value, group.mask);
9690
for (final String address : result.addresses) {
9791
memory.put(address, result.value);
9892
}
@@ -123,40 +117,46 @@ public static void main(final String[] args) throws Exception {
123117
);
124118
}
125119

126-
private static final List<String> TEST1 = splitLines(
127-
"mask = XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X\r\n" +
128-
"mem[8] = 11\r\n" +
129-
"mem[7] = 101\r\n" +
130-
"mem[8] = 0"
131-
);
132-
private static final List<String> TEST2 = splitLines(
133-
"mask = 000000000000000000000000000000X1001X\r\n" +
134-
"mem[42] = 100\r\n" +
135-
"mask = 00000000000000000000000000000000X0XX\r\n" +
136-
"mem[26] = 1"
137-
);
120+
private static final List<String> TEST1 = splitLines("""
121+
mask = XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X
122+
mem[8] = 11
123+
mem[7] = 101
124+
mem[8] = 0
125+
""");
126+
private static final List<String> TEST2 = splitLines("""
127+
mask = 000000000000000000000000000000X1001X
128+
mem[42] = 100
129+
mask = 00000000000000000000000000000000X0XX
130+
mem[26] = 1
131+
""");
138132

139-
@RequiredArgsConstructor
140-
@ToString
141-
private static final class Write {
142-
private final int address;
143-
private final int value;
144-
}
133+
private static final record Write(int address, int value) { }
145134

146-
@RequiredArgsConstructor
147-
@Builder
148-
@ToString
149-
private static final class Group {
150-
private final String mask;
151-
@Singular
152-
private final List<Write> writes;
135+
private static final record Group(String mask, List<Write> writes) {
136+
public static GroupBuilder builder() {
137+
return new GroupBuilder();
138+
}
139+
private static final class GroupBuilder {
140+
private String mask;
141+
private final List<Write> writes = new ArrayList<>();
142+
143+
public Group build() {
144+
return new Group(this.mask, this.writes);
145+
}
146+
147+
public GroupBuilder mask(final String mask) {
148+
this.mask = mask;
149+
return this;
150+
}
151+
152+
public GroupBuilder write(final Write write) {
153+
this.writes.add(write);
154+
return this;
155+
}
156+
}
153157
}
154158

155-
@RequiredArgsConstructor
156-
private static final class Result {
157-
private final List<String> addresses;
158-
private final long value;
159-
}
159+
private static final record Result(List<String> addresses, long value) { }
160160

161161
@FunctionalInterface
162162
private interface Strategy {

‎src/main/java/AoC2020_16.java

Lines changed: 58 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -15,11 +15,6 @@
1515
import com.github.pareronia.aoc.Range;
1616
import com.github.pareronia.aocd.Puzzle;
1717

18-
import lombok.Builder;
19-
import lombok.RequiredArgsConstructor;
20-
import lombok.Singular;
21-
import lombok.ToString;
22-
2318
public class AoC2020_16 extends AoCBase {
2419

2520
private final Set<Rule> rules;
@@ -39,11 +34,11 @@ private AoC2020_16(final List<String> input, final boolean debug) {
3934
}
4035

4136
private final Rule parseRule(final String s) {
42-
final String[] splits1 = s.split(": ");
43-
final Rule.RuleBuilder builder = Rule.builder();
37+
final var splits1 = s.split(": ");
38+
final var builder = Rule.builder();
4439
builder.field(splits1[0]);
45-
for (final String split : splits1[1].split(" or ")) {
46-
final String[] splits3 = split.split("-");
40+
for (final var split : splits1[1].split(" or ")) {
41+
final var splits3 = split.split("-");
4742
final int start = Integer.parseInt(splits3[0]);
4843
final int end = Integer.parseInt(splits3[1]);
4944
builder.validRange(Range.between(start, end));
@@ -93,50 +88,65 @@ public static void main(final String[] args) throws Exception {
9388
);
9489
}
9590

96-
private static final List<String> TEST1 = splitLines(
97-
"class: 1-3 or 5-7\r\n" +
98-
"row: 6-11 or 33-44\r\n" +
99-
"seat: 13-40 or 45-50\r\n" +
100-
"\r\n" +
101-
"your ticket:\r\n" +
102-
"7,1,14\r\n" +
103-
"\r\n" +
104-
"nearby tickets:\r\n" +
105-
"7,3,47\r\n" +
106-
"40,4,50\r\n" +
107-
"55,2,20\r\n" +
108-
"38,6,12"
109-
);
110-
private static final List<String> TEST2 = splitLines(
111-
"departure date: 0-1 or 4-19\r\n" +
112-
"departure time: 0-5 or 8-19\r\n" +
113-
"departure track: 0-13 or 16-19\r\n" +
114-
"\r\n" +
115-
"your ticket:\r\n" +
116-
"11,12,13\r\n" +
117-
"\r\n" +
118-
"nearby tickets:\r\n" +
119-
"3,9,18\r\n" +
120-
"15,1,5\r\n" +
121-
"5,14,9"
122-
);
91+
private static final List<String> TEST1 = splitLines("""
92+
class: 1-3 or 5-7
93+
row: 6-11 or 33-44
94+
seat: 13-40 or 45-50
95+
96+
your ticket:
97+
7,1,14
98+
99+
nearby tickets:
100+
7,3,47
101+
40,4,50
102+
55,2,20
103+
38,6,12
104+
""");
105+
private static final List<String> TEST2 = splitLines("""
106+
departure date: 0-1 or 4-19
107+
departure time: 0-5 or 8-19
108+
departure track: 0-13 or 16-19
109+
110+
your ticket:
111+
11,12,13
112+
113+
nearby tickets:
114+
3,9,18
115+
15,1,5
116+
5,14,9
117+
""");
123118

124-
@RequiredArgsConstructor
125-
@Builder
126-
@ToString
127-
private static final class Rule {
128-
private final String field;
129-
@Singular
130-
private final Set<Range> validRanges;
119+
private static final record Rule(String field, Set<Range> validRanges) {
131120

132121
public boolean validate(final int value) {
133122
return this.validRanges.stream().anyMatch(r -> r.contains(value));
134123
}
124+
125+
public static RuleBuilder builder() {
126+
return new RuleBuilder();
127+
}
128+
129+
private static final class RuleBuilder {
130+
private String field;
131+
private final Set<Range> validRanges = new HashSet<>();
132+
133+
public Rule build() {
134+
return new Rule(this.field, this.validRanges);
135+
}
136+
137+
public RuleBuilder field(final String field) {
138+
this.field = field;
139+
return this;
140+
}
141+
142+
public RuleBuilder validRange(final Range validRange) {
143+
this.validRanges.add(validRange);
144+
return this;
145+
}
146+
}
135147
}
136148

137-
@RequiredArgsConstructor
138-
private static final class Ticket {
139-
private final List<Integer> values;
149+
private static final record Ticket(List<Integer> values) {
140150

141151
public boolean invalid(final Set<Rule> rules) {
142152
return this.values.stream()
@@ -154,15 +164,9 @@ private Predicate<Integer> fieldDoesNotMatchAnyRule(final Set<Rule> rules) {
154164
}
155165
}
156166

157-
@RequiredArgsConstructor
158-
private static final class Match {
159-
private final Rule rule;
160-
private final int idx;
161-
}
167+
private static final record Match(Rule rule, int idx) { }
162168

163-
@RequiredArgsConstructor
164-
private static final class Matches {
165-
private final Map<Rule, Set<Integer>> matches;
169+
private static final record Matches(Map<Rule, Set<Integer>> matches) {
166170

167171
private static boolean matchColumn(final List<Ticket> tickets,
168172
final int column, final Rule rule) {

0 commit comments

Comments
 (0)