Skip to content

Commit 486e25a

Browse files
EbbDropEbbDrop
committed
Revert "Use bits in the inner parts of part2"
This reverts commit 5a738ab.
1 parent 5a738ab commit 486e25a

File tree

1 file changed

+72
-92
lines changed

1 file changed

+72
-92
lines changed

‎src/day6.rs‎

Lines changed: 72 additions & 92 deletions
Original file line numberDiff line numberDiff line change
@@ -98,66 +98,62 @@ fn try_opst_up(
9898
start_x: usize,
9999
start_y: usize,
100100

101-
hor_grid: &mut [BitArray<[u64; SIZE.div_ceil(64)]>; SIZE],
102-
vert_grid: &mut [BitArray<[u64; SIZE.div_ceil(64)]>; SIZE],
101+
hor_grid: &mut [[u8; SIZE]; SIZE],
102+
vert_grid: &mut [[u8; SIZE]; SIZE],
103103

104104
mut visited_vert: BitArray<[u64; (SIZE * SIZE).div_ceil(64)]>,
105105
mut visited_hor: BitArray<[u64; (SIZE * SIZE).div_ceil(64)]>,
106106
) -> bool {
107-
hor_grid[opst_y].set(opst_x, true);
108-
vert_grid[opst_x].set(opst_y, true);
107+
hor_grid[opst_y][opst_x] = b'#';
108+
vert_grid[opst_x][opst_y] = b'#';
109109

110110
let mut x = start_x;
111111
let mut y = start_y;
112112

113113
let loops = loop {
114114
// Up
115-
let y_move = vert_grid[x][..y].trailing_zeros();
116-
if y_move >= y {
115+
let Some(y_move) = memchr::memrchr(b'#', &vert_grid[x][..y]) else {
117116
break false;
118-
}
119-
y -= y_move;
117+
};
118+
y = y_move + 1;
120119
if visited_vert[y * SIZE + x] {
121120
break true;
122121
}
123122
visited_vert.set(y * SIZE + x, true);
124123

125124
// Right
126-
let x_move = hor_grid[y][x + 1..].leading_zeros();
127-
if x + x_move > SIZE {
125+
let Some(x_move) = memchr::memchr(b'#', &hor_grid[y][x + 1..]) else {
128126
break false;
129-
}
127+
};
130128
x += x_move;
131129
if visited_hor[y * SIZE + x] {
132130
break true;
133131
}
134132
visited_hor.set(y * SIZE + x, true);
135133

136134
// Down
137-
let y_move = vert_grid[x][y + 1..].leading_zeros();
138-
if y + y_move > SIZE {
135+
let Some(y_move) = memchr::memchr(b'#', &vert_grid[x][y + 1..]) else {
139136
break false;
140-
}
137+
};
141138
y += y_move;
142139
if visited_vert[y * SIZE + x] {
143140
break true;
144141
}
145142
visited_vert.set(y * SIZE + x, true);
146143

147144
// Left
148-
let x_move = hor_grid[y][..x].trailing_zeros();
149-
if x_move >= x {
145+
let Some(x_move) = memchr::memrchr(b'#', &hor_grid[y][..x]) else {
150146
break false;
151-
}
152-
x -= x_move;
147+
};
148+
x = x_move + 1;
153149
if visited_hor[y * SIZE + x] {
154150
break true;
155151
}
156152
visited_hor.set(y * SIZE + x, true);
157153
};
158154

159-
hor_grid[opst_y].set(opst_x, false);
160-
vert_grid[opst_x].set(opst_y, false);
155+
hor_grid[opst_y][opst_x] = 0;
156+
vert_grid[opst_x][opst_y] = 0;
161157

162158
loops
163159
}
@@ -168,66 +164,62 @@ fn try_opst_right(
168164
start_x: usize,
169165
start_y: usize,
170166

171-
hor_grid: &mut [BitArray<[u64; SIZE.div_ceil(64)]>; SIZE],
172-
vert_grid: &mut [BitArray<[u64; SIZE.div_ceil(64)]>; SIZE],
167+
hor_grid: &mut [[u8; SIZE]; SIZE],
168+
vert_grid: &mut [[u8; SIZE]; SIZE],
173169

174170
mut visited_vert: BitArray<[u64; (SIZE * SIZE).div_ceil(64)]>,
175171
mut visited_hor: BitArray<[u64; (SIZE * SIZE).div_ceil(64)]>,
176172
) -> bool {
177-
hor_grid[opst_y].set(opst_x, true);
178-
vert_grid[opst_x].set(opst_y, true);
173+
hor_grid[opst_y][opst_x] = b'#';
174+
vert_grid[opst_x][opst_y] = b'#';
179175

180176
let mut x = start_x;
181177
let mut y = start_y;
182178

183179
let loops = loop {
184180
// Right
185-
let x_move = hor_grid[y][x + 1..].leading_zeros();
186-
if x + x_move > SIZE {
181+
let Some(x_move) = memchr::memchr(b'#', &hor_grid[y][x + 1..]) else {
187182
break false;
188-
}
183+
};
189184
x += x_move;
190185
if visited_hor[y * SIZE + x] {
191186
break true;
192187
}
193188
visited_hor.set(y * SIZE + x, true);
194189

195190
// Down
196-
let y_move = vert_grid[x][y + 1..].leading_zeros();
197-
if y + y_move > SIZE {
191+
let Some(y_move) = memchr::memchr(b'#', &vert_grid[x][y + 1..]) else {
198192
break false;
199-
}
193+
};
200194
y += y_move;
201195
if visited_vert[y * SIZE + x] {
202196
break true;
203197
}
204198
visited_vert.set(y * SIZE + x, true);
205199

206200
// Left
207-
let x_move = hor_grid[y][..x].trailing_zeros();
208-
if x_move >= x {
201+
let Some(x_move) = memchr::memrchr(b'#', &hor_grid[y][..x]) else {
209202
break false;
210-
}
211-
x -= x_move;
203+
};
204+
x = x_move + 1;
212205
if visited_hor[y * SIZE + x] {
213206
break true;
214207
}
215208
visited_hor.set(y * SIZE + x, true);
216209

217210
// Up
218-
let y_move = vert_grid[x][..y].trailing_zeros();
219-
if y_move >= y {
211+
let Some(y_move) = memchr::memrchr(b'#', &vert_grid[x][..y]) else {
220212
break false;
221-
}
222-
y -= y_move;
213+
};
214+
y = y_move + 1;
223215
if visited_vert[y * SIZE + x] {
224216
break true;
225217
}
226218
visited_vert.set(y * SIZE + x, true);
227219
};
228220

229-
hor_grid[opst_y].set(opst_x, false);
230-
vert_grid[opst_x].set(opst_y, false);
221+
hor_grid[opst_y][opst_x] = 0;
222+
vert_grid[opst_x][opst_y] = 0;
231223

232224
loops
233225
}
@@ -238,66 +230,62 @@ fn try_opst_down(
238230
start_x: usize,
239231
start_y: usize,
240232

241-
hor_grid: &mut [BitArray<[u64; SIZE.div_ceil(64)]>; SIZE],
242-
vert_grid: &mut [BitArray<[u64; SIZE.div_ceil(64)]>; SIZE],
233+
hor_grid: &mut [[u8; SIZE]; SIZE],
234+
vert_grid: &mut [[u8; SIZE]; SIZE],
243235

244236
mut visited_vert: BitArray<[u64; (SIZE * SIZE).div_ceil(64)]>,
245237
mut visited_hor: BitArray<[u64; (SIZE * SIZE).div_ceil(64)]>,
246238
) -> bool {
247-
hor_grid[opst_y].set(opst_x, true);
248-
vert_grid[opst_x].set(opst_y, true);
239+
hor_grid[opst_y][opst_x] = b'#';
240+
vert_grid[opst_x][opst_y] = b'#';
249241

250242
let mut x = start_x;
251243
let mut y = start_y;
252244

253245
let loops = loop {
254246
// Down
255-
let y_move = vert_grid[x][y + 1..].leading_zeros();
256-
if y + y_move > SIZE {
247+
let Some(y_move) = memchr::memchr(b'#', &vert_grid[x][y + 1..]) else {
257248
break false;
258-
}
249+
};
259250
y += y_move;
260251
if visited_vert[y * SIZE + x] {
261252
break true;
262253
}
263254
visited_vert.set(y * SIZE + x, true);
264255

265256
// Left
266-
let x_move = hor_grid[y][..x].trailing_zeros();
267-
if x_move >= x {
257+
let Some(x_move) = memchr::memrchr(b'#', &hor_grid[y][..x]) else {
268258
break false;
269-
}
270-
x -= x_move;
259+
};
260+
x = x_move + 1;
271261
if visited_hor[y * SIZE + x] {
272262
break true;
273263
}
274264
visited_hor.set(y * SIZE + x, true);
275265

276266
// Up
277-
let y_move = vert_grid[x][..y].trailing_zeros();
278-
if y_move >= y {
267+
let Some(y_move) = memchr::memrchr(b'#', &vert_grid[x][..y]) else {
279268
break false;
280-
}
281-
y -= y_move;
269+
};
270+
y = y_move + 1;
282271
if visited_vert[y * SIZE + x] {
283272
break true;
284273
}
285274
visited_vert.set(y * SIZE + x, true);
286275

287276
// Right
288-
let x_move = hor_grid[y][x + 1..].leading_zeros();
289-
if x + x_move > SIZE {
277+
let Some(x_move) = memchr::memchr(b'#', &hor_grid[y][x + 1..]) else {
290278
break false;
291-
}
279+
};
292280
x += x_move;
293281
if visited_hor[y * SIZE + x] {
294282
break true;
295283
}
296284
visited_hor.set(y * SIZE + x, true);
297285
};
298286

299-
hor_grid[opst_y].set(opst_x, false);
300-
vert_grid[opst_x].set(opst_y, false);
287+
hor_grid[opst_y][opst_x] = 0;
288+
vert_grid[opst_x][opst_y] = 0;
301289

302290
loops
303291
}
@@ -308,66 +296,62 @@ fn try_opst_left(
308296
start_x: usize,
309297
start_y: usize,
310298

311-
hor_grid: &mut [BitArray<[u64; SIZE.div_ceil(64)]>; SIZE],
312-
vert_grid: &mut [BitArray<[u64; SIZE.div_ceil(64)]>; SIZE],
299+
hor_grid: &mut [[u8; SIZE]; SIZE],
300+
vert_grid: &mut [[u8; SIZE]; SIZE],
313301

314302
mut visited_vert: BitArray<[u64; (SIZE * SIZE).div_ceil(64)]>,
315303
mut visited_hor: BitArray<[u64; (SIZE * SIZE).div_ceil(64)]>,
316304
) -> bool {
317-
hor_grid[opst_y].set(opst_x, true);
318-
vert_grid[opst_x].set(opst_y, true);
305+
hor_grid[opst_y][opst_x] = b'#';
306+
vert_grid[opst_x][opst_y] = b'#';
319307

320308
let mut x = start_x;
321309
let mut y = start_y;
322310

323311
let loops = loop {
324312
// Left
325-
let x_move = hor_grid[y][..x].trailing_zeros();
326-
if x_move >= x {
313+
let Some(x_move) = memchr::memrchr(b'#', &hor_grid[y][..x]) else {
327314
break false;
328-
}
329-
x -= x_move;
315+
};
316+
x = x_move + 1;
330317
if visited_hor[y * SIZE + x] {
331318
break true;
332319
}
333320
visited_hor.set(y * SIZE + x, true);
334321

335322
// Up
336-
let y_move = vert_grid[x][..y].trailing_zeros();
337-
if y_move >= y {
323+
let Some(y_move) = memchr::memrchr(b'#', &vert_grid[x][..y]) else {
338324
break false;
339-
}
340-
y -= y_move;
325+
};
326+
y = y_move + 1;
341327
if visited_vert[y * SIZE + x] {
342328
break true;
343329
}
344330
visited_vert.set(y * SIZE + x, true);
345331

346332
// Right
347-
let x_move = hor_grid[y][x + 1..].leading_zeros();
348-
if x + x_move > SIZE {
333+
let Some(x_move) = memchr::memchr(b'#', &hor_grid[y][x + 1..]) else {
349334
break false;
350-
}
335+
};
351336
x += x_move;
352337
if visited_hor[y * SIZE + x] {
353338
break true;
354339
}
355340
visited_hor.set(y * SIZE + x, true);
356341

357342
// Down
358-
let y_move = vert_grid[x][y + 1..].leading_zeros();
359-
if y + y_move > SIZE {
343+
let Some(y_move) = memchr::memchr(b'#', &vert_grid[x][y + 1..]) else {
360344
break false;
361-
}
345+
};
362346
y += y_move;
363347
if visited_vert[y * SIZE + x] {
364348
break true;
365349
}
366350
visited_vert.set(y * SIZE + x, true);
367351
};
368352

369-
hor_grid[opst_y].set(opst_x, false);
370-
vert_grid[opst_x].set(opst_y, false);
353+
hor_grid[opst_y][opst_x] = 0;
354+
vert_grid[opst_x][opst_y] = 0;
371355

372356
loops
373357
}
@@ -378,8 +362,6 @@ pub fn part2(s: &str) -> u32 {
378362

379363
let mut hor_grid = [[0u8; SIZE]; SIZE];
380364
let mut vert_grid = [[0u8; SIZE]; SIZE];
381-
let mut hor_grid_bits = [BitArray::<[u64; SIZE.div_ceil(64)]>::default(); SIZE];
382-
let mut vert_grid_bits = [BitArray::<[u64; SIZE.div_ceil(64)]>::default(); SIZE];
383365

384366
let mut visited_vert = BitArray::<[u64; (SIZE * SIZE).div_ceil(64)]>::default();
385367
let mut visited_hor = BitArray::<[u64; (SIZE * SIZE).div_ceil(64)]>::default();
@@ -391,8 +373,6 @@ pub fn part2(s: &str) -> u32 {
391373

392374
hor_grid[y][x] = b'#';
393375
vert_grid[x][y] = b'#';
394-
hor_grid_bits[y].set(x, true);
395-
vert_grid_bits[x].set(y, true);
396376
}
397377

398378
let start = memchr::memchr(b'^', s).unwrap();
@@ -420,8 +400,8 @@ pub fn part2(s: &str) -> u32 {
420400
y - 1,
421401
x,
422402
y,
423-
&mut hor_grid_bits,
424-
&mut vert_grid_bits,
403+
&mut hor_grid,
404+
&mut vert_grid,
425405
visited_vert.clone(),
426406
visited_hor.clone(),
427407
) {
@@ -448,8 +428,8 @@ pub fn part2(s: &str) -> u32 {
448428
y,
449429
x,
450430
y,
451-
&mut hor_grid_bits,
452-
&mut vert_grid_bits,
431+
&mut hor_grid,
432+
&mut vert_grid,
453433
visited_vert.clone(),
454434
visited_hor.clone(),
455435
) {
@@ -476,8 +456,8 @@ pub fn part2(s: &str) -> u32 {
476456
y + 1,
477457
x,
478458
y,
479-
&mut hor_grid_bits,
480-
&mut vert_grid_bits,
459+
&mut hor_grid,
460+
&mut vert_grid,
481461
visited_vert.clone(),
482462
visited_hor.clone(),
483463
) {
@@ -504,8 +484,8 @@ pub fn part2(s: &str) -> u32 {
504484
y,
505485
x,
506486
y,
507-
&mut hor_grid_bits,
508-
&mut vert_grid_bits,
487+
&mut hor_grid,
488+
&mut vert_grid,
509489
visited_vert.clone(),
510490
visited_hor.clone(),
511491
) {

0 commit comments

Comments
 (0)