My attempts to solve puzzles of Advent of Code
feat: day 5 optimised
+674
-1
+174
data/2023/day5.txt
+174
data/2023/day5.txt
···
1
+
seeds: 194657215 187012821 1093203236 6077151 44187305 148722449 2959577030 152281079 3400626717 198691716 1333399202 287624830 2657325069 35258407 1913289352 410917164 1005856673 850939 839895010 162018909
2
+
3
+
seed-to-soil map:
4
+
466206721 134904099 264145987
5
+
3226739510 2500159633 122177414
6
+
1107118949 4139510909 155456387
7
+
2314679916 2622337047 59899451
8
+
2642618541 1908002826 511067679
9
+
0 399050086 167531444
10
+
1262575336 2682236498 1052104580
11
+
3448620320 1415756771 259155097
12
+
302435543 566581530 163771178
13
+
3348916924 4039807513 99703396
14
+
3153686220 1674911868 73053290
15
+
3788293662 1747965158 160037668
16
+
3948331330 3734341078 305466435
17
+
2374579367 1228806725 186950046
18
+
2561529413 2419070505 81089128
19
+
167531444 0 134904099
20
+
3707775417 1148288480 80518245
21
+
4253797765 1107118949 41169531
22
+
23
+
soil-to-fertilizer map:
24
+
3913658055 3217667557 44136240
25
+
3043638173 1755409772 387575354
26
+
1214033686 3261803797 213545970
27
+
3431213527 3475349767 482444528
28
+
1994011339 2522356968 695310589
29
+
2689321928 1214033686 354316245
30
+
1427579656 2142985126 379371842
31
+
1806951498 1568349931 187059841
32
+
33
+
fertilizer-to-water map:
34
+
2553394045 2097964132 64191777
35
+
3153687517 3499502814 665965431
36
+
1104565830 789107360 151317021
37
+
4084493704 2165934452 60088979
38
+
981078109 1551802916 123487721
39
+
2935219151 4165468245 66838136
40
+
10669639 1277616562 132965227
41
+
839228347 1410581789 141221127
42
+
3942173186 2018304529 79659603
43
+
393057134 444333135 344145590
44
+
2617585822 2253442971 317633329
45
+
4237573988 3156387517 57393308
46
+
1341340213 99436946 344896189
47
+
143634866 1746717555 204406814
48
+
776848617 0 21473714
49
+
386359019 1270918447 6698115
50
+
4168968434 3430897260 68605554
51
+
2497629182 3375132397 55764863
52
+
3819652948 3213780825 9721342
53
+
1686236402 940424381 47687418
54
+
4021832789 4232306381 62660915
55
+
4144582683 2162155909 3778543
56
+
1733923820 1675290637 30520902
57
+
737202724 21473714 39645893
58
+
2018304529 2591683508 479324653
59
+
798322331 1705811539 40906016
60
+
0 1260248808 10669639
61
+
980449474 788478725 628635
62
+
3002057287 3223502167 151630230
63
+
3829374290 2226023431 27419540
64
+
348041680 61119607 38317339
65
+
3856793830 3071008161 85379356
66
+
1764444722 1073569161 186679647
67
+
4148361226 2571076300 20607208
68
+
1255882851 988111799 85457362
69
+
70
+
water-to-light map:
71
+
3143216572 2396957585 46085818
72
+
2930160319 3087666064 82806318
73
+
3012966637 3275730008 11481558
74
+
1791164654 628261856 251676187
75
+
1156959152 1008045214 174725983
76
+
3597974089 4238330323 56636973
77
+
2659665097 3287211566 62612544
78
+
489714994 0 304501033
79
+
2323644539 2017991146 71374674
80
+
2611713237 3480351863 47951860
81
+
4135255968 3931716786 159711328
82
+
1331685135 879938043 128107171
83
+
2396957585 2748883399 70018348
84
+
408833803 1297158141 80881191
85
+
1469631779 1182771197 103330914
86
+
4004728215 3349824110 58812180
87
+
1012078485 2008335392 9655754
88
+
3024448195 2932857654 118768377
89
+
192304632 2089365820 87451432
90
+
4063540395 3408636290 71715573
91
+
3823753472 2665304126 83579273
92
+
117236420 1933267180 75068212
93
+
2218325460 1378039332 105319079
94
+
2722277641 3170472382 32223106
95
+
1459792306 618379493 9839473
96
+
3225342423 3528303723 55360789
97
+
901528396 304501033 110507199
98
+
3654611062 2471800766 96107890
99
+
1012035595 628218966 42890
100
+
1118925110 1719748519 38034042
101
+
3907332745 2567908656 97395470
102
+
2466975933 3786979482 144737304
103
+
794216027 1612436150 107312369
104
+
2901402956 2443043403 28757363
105
+
0 415008232 117236420
106
+
3750718952 3202695488 73034520
107
+
3189302390 3051626031 36040033
108
+
3394659119 3583664512 203314970
109
+
2754500747 4091428114 146902209
110
+
2042840841 1757782561 175484619
111
+
3280703212 2818901747 113955907
112
+
1021734239 532244652 86134841
113
+
279756064 1483358411 129077739
114
+
1572962693 2176817252 218201961
115
+
1107869080 1286102111 11056030
116
+
117
+
light-to-temperature map:
118
+
1609050489 2309171782 372577802
119
+
2023682469 2836643763 897111138
120
+
834447570 143604042 411534753
121
+
428779503 1217157762 28824561
122
+
143604042 931982301 108906615
123
+
252510657 1040888916 176268846
124
+
3431278062 1484221851 471209429
125
+
1981628291 3733754901 42054178
126
+
4140073117 2681749584 154894179
127
+
1484221851 4170138658 124828638
128
+
3902487491 1955431280 237585626
129
+
457604064 555138795 376843506
130
+
3036948483 3775809079 394329579
131
+
2920793607 2193016906 116154876
132
+
133
+
temperature-to-humidity map:
134
+
1348484361 0 45849582
135
+
1394333943 726347262 166590764
136
+
1797084784 3346946555 119105515
137
+
1163891565 1265639794 165909682
138
+
2199751891 3274125222 72821333
139
+
4012454029 2231107899 181228118
140
+
1008425725 207338839 56688993
141
+
2322219090 3174539335 24543729
142
+
3987057737 3199083064 25396292
143
+
1560924707 45849582 62712410
144
+
3424140824 1837299459 190417072
145
+
2272573224 3224479356 27702302
146
+
2346762819 2412336017 518856401
147
+
329181964 1432789749 172164254
148
+
3783666369 2027716531 203391368
149
+
753484930 471406467 254940795
150
+
1916190299 2931192418 243346917
151
+
501346218 892938026 44760077
152
+
1329801247 1604954003 18683114
153
+
2865619220 3567337219 558521604
154
+
546106295 264027832 207378635
155
+
2300275526 3252181658 21943564
156
+
4193682147 3466052070 101285149
157
+
327941691 1431549476 1240273
158
+
0 937698103 327941691
159
+
2159537216 1797084784 40214675
160
+
3614557896 4125858823 169108473
161
+
1065114718 108561992 98776847
162
+
163
+
humidity-to-location map:
164
+
440744287 1133551978 536306564
165
+
4042633851 4000620330 37465866
166
+
977050851 1669858542 136276424
167
+
2136551597 4038086196 256881100
168
+
198620952 0 242123335
169
+
1113327275 242123335 891428643
170
+
4080099717 3802748040 197872290
171
+
2695699324 2136551597 1346934527
172
+
4277972007 3785752751 16995289
173
+
2393432697 3483486124 302266627
174
+
0 1806134966 198620952
+1
-1
src/main.rs
+1
-1
src/main.rs
+495
src/solutions/year_2023/day5.rs
+495
src/solutions/year_2023/day5.rs
···
1
+
use std::cmp::Ordering;
2
+
use crate::solutions::year_2023::day5::Map::MapTuple;
3
+
use aoc_lib::{create_solution, Input, Solver};
4
+
use chrono::Offset;
5
+
use std::ops::Range;
6
+
7
+
type PropertyTuple = (usize, usize, usize);
8
+
type PropertyRange = (Range<usize>, Range<usize>);
9
+
10
+
#[derive(PartialEq, Debug, Clone, Eq)]
11
+
enum Map {
12
+
MapTuple(PropertyTuple),
13
+
MapRange(PropertyRange),
14
+
}
15
+
16
+
impl Ord for Map {
17
+
fn cmp(&self, other: &Self) -> Ordering {
18
+
self.partial_cmp(other).unwrap_or(Ordering::Equal)
19
+
}
20
+
}
21
+
22
+
impl PartialOrd for Map {
23
+
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
24
+
match self {
25
+
Map::MapRange((start_range, _)) => {
26
+
start_range.start.partial_cmp(match other {
27
+
Map::MapRange((other_start_range, _)) => &other_start_range.start,
28
+
Map::MapTuple((s, _, _)) => &s,
29
+
})
30
+
}
31
+
Map::MapTuple((s, _, _)) => s.partial_cmp(match other {
32
+
Map::MapTuple((s, _, _)) => s,
33
+
Map::MapRange((start_range, _)) => &start_range.start,
34
+
}),
35
+
}
36
+
}
37
+
}
38
+
39
+
impl Map {
40
+
fn map_tuple(s: usize, d: usize, r: usize) -> Map {
41
+
Map::MapTuple((s, d, r))
42
+
}
43
+
44
+
fn map_range(x: (usize, usize, usize)) -> Map {
45
+
Map::MapRange(((x.0..x.0 + x.2), (x.1..x.1 + x.2)))
46
+
}
47
+
48
+
fn head(&self) -> usize {
49
+
match self {
50
+
MapTuple(x) => x.0,
51
+
Map::MapRange(x) => x.0.start,
52
+
}
53
+
}
54
+
55
+
fn map_tuple_iter(iter: Vec<(usize, usize, usize)>) -> Vec<Self> {
56
+
iter.into_iter().map(|x| x.into()).collect()
57
+
}
58
+
59
+
fn map_range_iter(iter: Vec<(usize, usize, usize)>) -> Vec<Self> {
60
+
iter.into_iter().map(|x| Map::map_range(x)).collect()
61
+
}
62
+
63
+
fn map_range_iters(iters: Vec<Vec<(usize, usize, usize)>>) -> Vec<Vec<Self>> {
64
+
iters.into_iter().map(|x| Map::map_range_iter(x)).collect()
65
+
}
66
+
67
+
fn map_tuple_iters(iters: Vec<Vec<(usize, usize, usize)>>) -> Vec<Vec<Self>> {
68
+
iters.into_iter().map(|x| Map::map_tuple_iter(x)).collect()
69
+
}
70
+
}
71
+
72
+
impl From<(usize, usize, usize)> for Map {
73
+
fn from(value: (usize, usize, usize)) -> Self {
74
+
Map::map_tuple(value.0, value.1, value.2)
75
+
}
76
+
}
77
+
78
+
fn get_mapped_value(
79
+
key: usize,
80
+
source_start: usize,
81
+
destination_start: usize,
82
+
range_length: usize,
83
+
) -> Option<usize> {
84
+
// if key >= source_start then look for corresponding mapped_value
85
+
if key >= source_start {
86
+
// the distance of key from source_start <= range_length
87
+
let distance = key - source_start;
88
+
if distance <= range_length {
89
+
// mapped_value = destination_start + distance
90
+
Some(destination_start + distance)
91
+
} else {
92
+
None
93
+
}
94
+
} else {
95
+
None
96
+
}
97
+
}
98
+
99
+
/// If a is consumed in b then respond a tuple with left half as a and right as empty range
100
+
/// if not then respond with a tuple where left half represents consumed and right not consumed
101
+
/// if a and b are disjoint then respond None
102
+
fn range_mapping(
103
+
a: Range<usize>,
104
+
b: Range<usize>,
105
+
) -> Option<(Range<usize>, Range<usize>)> {
106
+
if a.end <= b.start || a.start >= b.end {
107
+
// disjoint
108
+
None
109
+
} else if a.start >= b.start && a.end <= b.end {
110
+
// a is fully consumed within b
111
+
Some((a, 0..0))
112
+
} else if a.start >= b.start && a.end > b.end {
113
+
// some part of a in the end is not consumed
114
+
Some((a.start..b.end, b.end..a.end))
115
+
} else if a.start < b.start && a.end <= b.end {
116
+
// some part of a in the start is not consumed
117
+
Some((b.start..a.end, a.start..b.start))
118
+
} else {
119
+
None
120
+
}
121
+
}
122
+
123
+
/// get all the mapped destination ranges from the map for a key_range
124
+
fn range_mapping_over(
125
+
key_range: Range<usize>,
126
+
map: Vec<Map>,
127
+
) -> Vec<Range<usize>> {
128
+
let ret = map
129
+
.iter()
130
+
.fold(
131
+
(vec![], key_range.clone()),
132
+
|(mut acc, current_unmapped), m| {
133
+
match m {
134
+
Map::MapRange((start_range, destination_range)) => {
135
+
return if let Some((mapped, unmapped)) =
136
+
range_mapping(current_unmapped.clone(), start_range.clone())
137
+
{
138
+
let destination_start_offset = mapped.start - start_range.start;
139
+
let destination_start =
140
+
destination_range.start + destination_start_offset;
141
+
142
+
acc.push(destination_start..(destination_start + mapped.len()));
143
+
acc.sort_by(|a, b| a.start.cmp(&b.start));
144
+
145
+
(acc, unmapped)
146
+
} else {
147
+
(acc, current_unmapped)
148
+
};
149
+
}
150
+
Map::MapTuple(_) => todo!(),
151
+
};
152
+
},
153
+
);
154
+
155
+
if ret.0.is_empty() {
156
+
if ret.1.is_empty() {
157
+
vec![key_range]
158
+
} else {
159
+
vec![ret.1]
160
+
}
161
+
} else {
162
+
let mut curr_acc = ret.0.clone();
163
+
if !ret.1.is_empty() {
164
+
curr_acc.push(ret.1);
165
+
}
166
+
curr_acc
167
+
}
168
+
}
169
+
170
+
fn range_mapping_over_maps(
171
+
key_range: Range<usize>,
172
+
maps: Vec<Vec<Map>>,
173
+
) -> Vec<Range<usize>> {
174
+
maps.into_iter().fold(vec![key_range], |acc, mut map| {
175
+
map.sort();
176
+
let ret = acc
177
+
.iter()
178
+
.flat_map(|r| range_mapping_over(r.clone(), map.clone()))
179
+
.collect::<Vec<_>>();
180
+
ret
181
+
})
182
+
}
183
+
184
+
fn range_mappings_over_maps(
185
+
ranges: Vec<Range<usize>>,
186
+
maps: Vec<Vec<Map>>,
187
+
) -> Vec<Range<usize>> {
188
+
let mut ret: Vec<_> = ranges.into_iter().flat_map(|r| {
189
+
let result_map = range_mapping_over_maps(r.clone(), maps.clone());
190
+
result_map
191
+
}).collect();
192
+
ret.sort_by(|a, b| a.start.cmp(&b.start));
193
+
ret
194
+
}
195
+
196
+
pub fn get_mapped_value_from(key: usize, map: Vec<Map>) -> usize {
197
+
map
198
+
.into_iter()
199
+
.find_map(|m| match m {
200
+
Map::MapTuple((source_start, destination_start, range_length)) => {
201
+
get_mapped_value(key, source_start, destination_start, range_length)
202
+
}
203
+
Map::MapRange((start_range, destination_range)) => todo!(),
204
+
})
205
+
.unwrap_or(key)
206
+
}
207
+
208
+
pub fn get_mapped_value_from_maps(key: usize, maps: Vec<Vec<Map>>) -> usize {
209
+
maps
210
+
.into_iter()
211
+
.fold(key, |acc, m| get_mapped_value_from(acc, m))
212
+
}
213
+
214
+
pub fn get_min_value(keys: Vec<usize>, maps: Vec<Vec<Map>>) -> usize {
215
+
keys
216
+
.into_iter()
217
+
.fold(vec![], |mut xs, k| {
218
+
let v = get_mapped_value_from_maps(k, maps.clone());
219
+
xs.push(v.min(usize::MAX));
220
+
xs
221
+
})
222
+
.iter()
223
+
.min()
224
+
.cloned()
225
+
.unwrap_or_default()
226
+
}
227
+
228
+
fn vec_to_ranges(keys: Vec<usize>) -> Vec<Range<usize>> {
229
+
keys
230
+
.chunks(2)
231
+
.map(|xs| (xs[0]..xs[0] + xs.get(1).unwrap_or(&0_usize)))
232
+
.collect::<Vec<_>>()
233
+
}
234
+
235
+
pub fn get_min_value_over_ranges(
236
+
keys: Vec<usize>,
237
+
maps: Vec<Vec<Map>>,
238
+
) -> usize {
239
+
vec_to_ranges(keys)
240
+
.into_iter()
241
+
.fold(vec![], |mut xs, ks| {
242
+
let ks = ks.collect::<Vec<_>>();
243
+
let min = get_min_value(ks, maps.clone());
244
+
xs.push(min);
245
+
xs
246
+
})
247
+
.iter()
248
+
.min()
249
+
.cloned()
250
+
.unwrap_or_default()
251
+
}
252
+
253
+
fn get_mapped_value_range(
254
+
key: usize,
255
+
key_range: usize,
256
+
source_start: usize,
257
+
destination_start: usize,
258
+
range_length: usize,
259
+
) -> Vec<usize> {
260
+
(key..key + key_range)
261
+
.map(|k| {
262
+
get_mapped_value(k, source_start, destination_start, range_length)
263
+
.unwrap_or(k)
264
+
})
265
+
.collect()
266
+
}
267
+
268
+
fn load_seeds(input: Input) -> Vec<usize> {
269
+
input
270
+
.lines
271
+
.iter()
272
+
.find_map(|l| {
273
+
l.split_once("seeds:").map(|l| {
274
+
l.1
275
+
.trim()
276
+
.split(' ')
277
+
.map(|x| x.parse().unwrap_or(0))
278
+
.collect::<Vec<usize>>()
279
+
})
280
+
})
281
+
.unwrap_or_default()
282
+
}
283
+
284
+
fn load_map(line: &str, as_range: bool) -> Option<Map> {
285
+
let vs: Vec<usize> = line
286
+
.trim()
287
+
.split(' ')
288
+
.map(|xs| xs.parse().unwrap_or(0))
289
+
.collect();
290
+
if vs.iter().take(3).len() == 3 {
291
+
if !as_range {
292
+
Some(Map::map_tuple(vs[1], vs[0], vs[2]))
293
+
} else {
294
+
Some(Map::map_range((vs[1], vs[0], vs[2])))
295
+
}
296
+
} else {
297
+
None
298
+
}
299
+
}
300
+
301
+
fn load_maps(input: Input, as_ranges: bool) -> Vec<Vec<Map>> {
302
+
input
303
+
.lines
304
+
.iter()
305
+
.fold((vec![vec![]], None), |(mut ms, map_name), l| {
306
+
if l.ends_with("map:") {
307
+
// hold the current map name
308
+
let map_name = l.trim().split_once(' ').map(|x| x.0);
309
+
(ms, map_name)
310
+
} else if !l.is_empty() && !l.starts_with("seeds:") {
311
+
// load the records for the current map name
312
+
if let Some(m) = load_map(&l, as_ranges) {
313
+
if let Some(xs) = ms.last_mut() {
314
+
xs.push(m);
315
+
}
316
+
317
+
(ms, map_name)
318
+
} else {
319
+
// ignore if for some reason records could not load
320
+
(ms, map_name)
321
+
}
322
+
} else if l.is_empty() && map_name.is_some() {
323
+
// setup for the next map name
324
+
325
+
// sort the last map by the source
326
+
if let Some(xs) = ms.last_mut() {
327
+
xs.sort_by(|x, y| x.head().cmp(&y.head()))
328
+
}
329
+
ms.push(vec![]);
330
+
(ms, None)
331
+
} else {
332
+
// ignore the seeds line
333
+
(ms, map_name)
334
+
}
335
+
})
336
+
.0
337
+
}
338
+
339
+
pub struct Day5 {}
340
+
341
+
create_solution!(
342
+
out_1 => usize;
343
+
out_2 => usize;
344
+
year => 2023;
345
+
day => 5;
346
+
sol_1 => |input: Input| {
347
+
let seeds = load_seeds(input.clone());
348
+
let maps = load_maps(input, false);
349
+
let v = get_min_value(seeds, maps);
350
+
Some(v)
351
+
};
352
+
sol_2 => |input: Input| {
353
+
let seeds = load_seeds(input.clone());
354
+
let maps = load_maps(input, true);
355
+
let vs = range_mappings_over_maps(vec_to_ranges(seeds.clone()), maps.clone());
356
+
357
+
vs.first().map(|x| x.start)
358
+
};
359
+
);
360
+
361
+
#[cfg(test)]
362
+
mod tests {
363
+
use super::*;
364
+
365
+
#[test]
366
+
fn test_get_mapped_value_from() {
367
+
let input: Vec<Map> =
368
+
vec![Map::map_tuple(98, 50, 2), Map::map_tuple(50, 52, 48)];
369
+
let v = get_mapped_value_from(79, input);
370
+
assert_eq!(v, 81);
371
+
}
372
+
373
+
#[test]
374
+
fn test_get_min_from() {
375
+
let maps: Vec<Vec<Map>> = Map::map_tuple_iters(vec![
376
+
vec![(98, 50, 2), (50, 52, 48)],
377
+
vec![(15, 0, 37), (52, 37, 2), (0, 39, 15)],
378
+
vec![(53, 49, 8), (11, 0, 42), (0, 42, 7), (7, 57, 4)],
379
+
vec![(18, 88, 7), (25, 18, 70)],
380
+
vec![(77, 45, 23), (45, 81, 19), (64, 68, 13)],
381
+
vec![(69, 0, 1), (0, 1, 69)],
382
+
vec![(56, 60, 37), (93, 56, 4)],
383
+
]);
384
+
385
+
let keys: Vec<usize> = vec![79, 14, 55, 13];
386
+
387
+
let act = get_min_value_over_ranges(keys, maps);
388
+
assert_eq!(act, 46);
389
+
}
390
+
391
+
392
+
#[test]
393
+
fn test_load_seeds() {
394
+
let seeds_line = "seeds: 194657215 187012821 1093203236 6077151 44187305 148722449 2959577030 152281079 3400626717 198691716 1333399202 287624830 2657325069 35258407 1913289352 410917164 1005856673 850939 839895010 162018909";
395
+
let act = load_seeds(Input {
396
+
lines: vec![seeds_line.to_string()],
397
+
});
398
+
let exp: Vec<usize> = vec![
399
+
194657215, 187012821, 1093203236, 6077151, 44187305, 148722449,
400
+
2959577030, 152281079, 3400626717, 198691716, 1333399202, 287624830,
401
+
2657325069, 35258407, 1913289352, 410917164, 1005856673, 850939,
402
+
839895010, 162018909,
403
+
];
404
+
assert_eq!(exp, act);
405
+
}
406
+
407
+
#[test]
408
+
fn test_load_maps() {
409
+
let maps_lines = r"seeds: 79 14 55 13
410
+
411
+
seed-to-soil map:
412
+
50 98 2
413
+
52 50 48
414
+
415
+
soil-to-fertilizer map:
416
+
0 15 37
417
+
37 52 2
418
+
39 0 15
419
+
420
+
fertilizer-to-water map:
421
+
49 53 8
422
+
0 11 42
423
+
42 0 7
424
+
57 7 4
425
+
426
+
water-to-light map:
427
+
88 18 7
428
+
18 25 70
429
+
430
+
light-to-temperature map:
431
+
45 77 23
432
+
81 45 19
433
+
68 64 13
434
+
435
+
temperature-to-humidity map:
436
+
0 69 1
437
+
1 0 69
438
+
439
+
humidity-to-location map:
440
+
60 56 37
441
+
56 93 4
442
+
";
443
+
let input = Input {
444
+
lines: maps_lines.split("\n").map(|x| x.to_string()).collect(),
445
+
};
446
+
let act = load_maps(input.clone(), false);
447
+
let act1 = load_maps(input.clone(), true);
448
+
let exp: Vec<Vec<Map>> = Map::map_tuple_iters(vec![
449
+
vec![(50, 52, 48), (98, 50, 2)],
450
+
vec![(0, 39, 15), (15, 0, 37), (52, 37, 2)],
451
+
vec![(0, 42, 7), (7, 57, 4), (11, 0, 42), (53, 49, 8)],
452
+
vec![(18, 88, 7), (25, 18, 70)],
453
+
vec![(45, 81, 19), (64, 68, 13), (77, 45, 23)],
454
+
vec![(0, 1, 69), (69, 0, 1)],
455
+
vec![(56, 60, 37), (93, 56, 4)],
456
+
]);
457
+
458
+
let exp1: Vec<Vec<Map>> = Map::map_range_iters(vec![
459
+
vec![(98, 50, 2), (50, 52, 48)],
460
+
vec![(15, 0, 37), (52, 37, 2), (0, 39, 15)],
461
+
vec![(53, 49, 8), (11, 0, 42), (0, 42, 7), (7, 57, 4)],
462
+
vec![(18, 88, 7), (25, 18, 70)],
463
+
vec![(77, 45, 23), (45, 81, 19), (64, 68, 13)],
464
+
vec![(69, 0, 1), (0, 1, 69)],
465
+
vec![(56, 60, 37), (93, 56, 4)],
466
+
]);
467
+
468
+
assert_eq!(act, exp);
469
+
assert_eq!(act1, exp1);
470
+
}
471
+
472
+
473
+
474
+
#[test]
475
+
fn test_range_mapping_over_map() {
476
+
477
+
let keys: Vec<usize> = vec![79, 14, 55, 13];
478
+
479
+
480
+
let maps: Vec<Vec<Map>> = Map::map_range_iters(vec![
481
+
vec![(98, 50, 2), (50, 52, 48)],
482
+
vec![(15, 0, 37), (52, 37, 2), (0, 39, 15)],
483
+
vec![(53, 49, 8), (11, 0, 42), (0, 42, 7), (7, 57, 4)],
484
+
vec![(18, 88, 7), (25, 18, 70)],
485
+
vec![(77, 45, 23), (45, 81, 19), (64, 68, 13)],
486
+
vec![(69, 0, 1), (0, 1, 69)],
487
+
vec![(56, 60, 37), (93, 56, 4)],
488
+
]);
489
+
490
+
let ks = vec_to_ranges(keys);
491
+
492
+
let x = range_mappings_over_maps(ks, maps);
493
+
assert_eq!(x, vec![46..56, 56..60, 60..61, 82..85, 86..90, 94..97, 97..99])
494
+
}
495
+
}