543 lines
17 KiB
Rust
543 lines
17 KiB
Rust
use std::ops::Range;
|
|
|
|
use nom::{
|
|
bytes::complete::tag,
|
|
character::complete::{alpha1, multispace0},
|
|
multi::{count, many1, separated_list1},
|
|
sequence::{delimited, preceded, terminated},
|
|
IResult,
|
|
};
|
|
|
|
pub type SeedRange = Range<u64>;
|
|
|
|
#[derive(Debug, PartialEq, Eq)]
|
|
pub struct Map {
|
|
pub from: String,
|
|
pub to: String,
|
|
pub ranges: Vec<MapRange>,
|
|
}
|
|
|
|
impl Map {
|
|
pub fn map_ranges(&self, seeds: SeedRange) -> Vec<SeedRange> {
|
|
let mut unprocessed_seeds = vec![seeds];
|
|
let mut processed_seeds = Vec::new();
|
|
//using this instead of a for loop so that we can continue to push new stuff onto the
|
|
//unprocessed queue
|
|
while let Some(seed) = unprocessed_seeds.pop() {
|
|
//find map with intersection with seed
|
|
let map_to_apply = self
|
|
.ranges
|
|
.iter()
|
|
.find(|&map_range| !map_range.intersection_with_seed(&seed).is_empty());
|
|
|
|
let Some(map_to_apply) = map_to_apply else {
|
|
//if no mapping to do, consider seed processed
|
|
processed_seeds.push(seed);
|
|
continue;
|
|
};
|
|
|
|
let map_end = map_to_apply.src_start + map_to_apply.len;
|
|
let offset = map_to_apply.dest_start as i64 - map_to_apply.src_start as i64;
|
|
let intersection = map_to_apply.intersection_with_seed(&seed);
|
|
|
|
processed_seeds.push(Range {
|
|
start: (intersection.start as i64 + offset) as u64,
|
|
end: (intersection.end as i64 + offset) as u64,
|
|
});
|
|
|
|
//add the part before the map range back to the queue
|
|
if seed.start < map_to_apply.src_start {
|
|
unprocessed_seeds.push(Range {
|
|
start: seed.start,
|
|
end: intersection.start,
|
|
})
|
|
};
|
|
|
|
//add the part after the map range back to the queue
|
|
if seed.end > map_end {
|
|
unprocessed_seeds.push(Range {
|
|
start: intersection.end,
|
|
end: seed.end,
|
|
})
|
|
};
|
|
}
|
|
processed_seeds
|
|
}
|
|
|
|
pub fn map(&self, src: u64) -> u64 {
|
|
for range in &self.ranges {
|
|
if range.is_applicable(&src) {
|
|
return range.map(src);
|
|
}
|
|
}
|
|
src
|
|
}
|
|
fn parse(input: &str) -> IResult<&str, Self> {
|
|
let (input, (from, to)) = delimited(multispace0, Self::parse_to_from, multispace0)(input)?;
|
|
let (input, ranges) = many1(MapRange::parse)(input)?;
|
|
Ok((input, Map { from, to, ranges }))
|
|
}
|
|
fn parse_to_from(input: &str) -> IResult<&str, (String, String)> {
|
|
let (input, from) = alpha1(input)?;
|
|
let (input, to) = terminated(preceded(tag("-to-"), alpha1), tag(" map:\n"))(input)?;
|
|
Ok((input, (from.to_string(), to.to_string())))
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Eq)]
|
|
pub struct MapRange {
|
|
pub dest_start: u64,
|
|
pub src_start: u64,
|
|
pub len: u64,
|
|
}
|
|
|
|
impl MapRange {
|
|
fn intersection_with_seed(&self, seed: &SeedRange) -> SeedRange {
|
|
seed.start.max(self.src_start)..seed.end.min(self.src_start + self.len)
|
|
}
|
|
|
|
fn is_applicable(&self, src: &u64) -> bool {
|
|
self.src_start <= *src && *src < (self.src_start + self.len)
|
|
}
|
|
|
|
fn map(&self, src: u64) -> u64 {
|
|
if self.is_applicable(&src) {
|
|
let offset = src - self.src_start;
|
|
self.dest_start + offset
|
|
} else {
|
|
src
|
|
}
|
|
}
|
|
|
|
fn parse(input: &str) -> IResult<&str, Self> {
|
|
let number = delimited(multispace0, nom::character::complete::u64, multispace0);
|
|
let (input, numbers) = count(number, 3)(input)?;
|
|
Ok((
|
|
input,
|
|
MapRange {
|
|
dest_start: numbers[0],
|
|
src_start: numbers[1],
|
|
len: numbers[2],
|
|
},
|
|
))
|
|
}
|
|
}
|
|
|
|
fn parse_input(input: &str) -> IResult<&str, (Vec<u64>, Vec<Map>)> {
|
|
let (input, seeds) = preceded(
|
|
tag("seeds: "),
|
|
separated_list1(tag(" "), nom::character::complete::u64),
|
|
)(input)?;
|
|
let (input, maps) = many1(Map::parse)(input)?;
|
|
Ok((input, (seeds, maps)))
|
|
}
|
|
|
|
pub fn parse(input: &str) -> (Vec<u64>, Vec<Map>) {
|
|
parse_input(input).unwrap().1
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_map_range() {
|
|
let tested = Map {
|
|
from: "seed".to_string(),
|
|
to: "soil".to_string(),
|
|
ranges: vec![
|
|
MapRange {
|
|
dest_start: 50,
|
|
src_start: 98,
|
|
len: 2,
|
|
},
|
|
MapRange {
|
|
dest_start: 52,
|
|
src_start: 50,
|
|
len: 48,
|
|
},
|
|
],
|
|
};
|
|
let input: SeedRange = 40..120;
|
|
assert_eq!(
|
|
tested.map_ranges(input),
|
|
vec![
|
|
50..52,
|
|
100..120,
|
|
52..100,
|
|
40..50
|
|
]
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn test_intersection_with_seed() {
|
|
let tested = MapRange {
|
|
dest_start: 52,
|
|
src_start: 50,
|
|
len: 48,
|
|
};
|
|
let input: SeedRange = 80..120;
|
|
assert_eq!(tested.intersection_with_seed(&input), 80..98);
|
|
let input: SeedRange = 40..60;
|
|
assert_eq!(tested.intersection_with_seed(&input), 50..60);
|
|
let input: SeedRange = 55..79;
|
|
assert_eq!(tested.intersection_with_seed(&input), 55..79);
|
|
let input: SeedRange = 40..120;
|
|
assert_eq!(tested.intersection_with_seed(&input), 50..98);
|
|
}
|
|
|
|
#[test]
|
|
fn test_map() {
|
|
let tested = Map {
|
|
from: "seed".to_string(),
|
|
to: "soil".to_string(),
|
|
ranges: vec![
|
|
MapRange {
|
|
dest_start: 50,
|
|
src_start: 98,
|
|
len: 2,
|
|
},
|
|
MapRange {
|
|
dest_start: 52,
|
|
src_start: 50,
|
|
len: 48,
|
|
},
|
|
],
|
|
};
|
|
let input = [79, 14, 55, 13];
|
|
let output = input.map(|i| tested.map(i));
|
|
assert_eq!(output, [81, 14, 57, 13])
|
|
}
|
|
|
|
#[test]
|
|
fn test_is_appliccable() {
|
|
let tested = MapRange {
|
|
dest_start: 50,
|
|
src_start: 98,
|
|
len: 2,
|
|
};
|
|
assert!(tested.is_applicable(&99));
|
|
assert!(!tested.is_applicable(&100));
|
|
assert!(!tested.is_applicable(&97));
|
|
}
|
|
|
|
#[test]
|
|
fn test_range_map() {
|
|
let tested = MapRange {
|
|
dest_start: 52,
|
|
src_start: 50,
|
|
len: 48,
|
|
};
|
|
assert_eq!(tested.map(79), 81);
|
|
assert_eq!(tested.map(100), 100);
|
|
}
|
|
|
|
#[test]
|
|
fn test_map_parse() {
|
|
let input = concat!("seed-to-soil map:\n", "50 98 2\n", "52 50 48\n", "\n",);
|
|
assert_eq!(
|
|
Map::parse(input).unwrap(),
|
|
(
|
|
"",
|
|
Map {
|
|
from: "seed".to_string(),
|
|
to: "soil".to_string(),
|
|
ranges: vec![
|
|
MapRange {
|
|
dest_start: 50,
|
|
src_start: 98,
|
|
len: 2
|
|
},
|
|
MapRange {
|
|
dest_start: 52,
|
|
src_start: 50,
|
|
len: 48
|
|
},
|
|
]
|
|
},
|
|
)
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn test_range_parse() {
|
|
assert_eq!(
|
|
MapRange::parse("50 98 2\n").unwrap(),
|
|
(
|
|
"",
|
|
MapRange {
|
|
dest_start: 50,
|
|
src_start: 98,
|
|
len: 2,
|
|
}
|
|
)
|
|
);
|
|
assert_eq!(
|
|
MapRange::parse("0 15 37\n").unwrap(),
|
|
(
|
|
"",
|
|
MapRange {
|
|
dest_start: 0,
|
|
src_start: 15,
|
|
len: 37,
|
|
}
|
|
)
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_to_from() {
|
|
assert_eq!(
|
|
Map::parse_to_from("seed-to-soil map:\n").unwrap(),
|
|
("", ("seed".to_string(), "soil".to_string()))
|
|
);
|
|
assert_eq!(
|
|
Map::parse_to_from("hello-to-world map:\n").unwrap(),
|
|
("", ("hello".to_string(), "world".to_string()))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_input() {
|
|
let input = concat!(
|
|
"seeds: 79 14 55 13\n",
|
|
"\n",
|
|
"seed-to-soil map:\n",
|
|
"50 98 2\n",
|
|
"52 50 48\n",
|
|
"\n",
|
|
"soil-to-fertilizer map:\n",
|
|
"0 15 37\n",
|
|
"37 52 2\n",
|
|
"39 0 15\n",
|
|
);
|
|
assert_eq!(
|
|
parse_input(input).unwrap(),
|
|
(
|
|
"",
|
|
(
|
|
vec![79, 14, 55, 13],
|
|
vec![
|
|
Map {
|
|
from: "seed".to_string(),
|
|
to: "soil".to_string(),
|
|
ranges: vec![
|
|
MapRange {
|
|
dest_start: 50,
|
|
src_start: 98,
|
|
len: 2
|
|
},
|
|
MapRange {
|
|
dest_start: 52,
|
|
src_start: 50,
|
|
len: 48
|
|
},
|
|
]
|
|
},
|
|
Map {
|
|
from: "soil".to_string(),
|
|
to: "fertilizer".to_string(),
|
|
ranges: vec![
|
|
MapRange {
|
|
dest_start: 0,
|
|
src_start: 15,
|
|
len: 37
|
|
},
|
|
MapRange {
|
|
dest_start: 37,
|
|
src_start: 52,
|
|
len: 2
|
|
},
|
|
MapRange {
|
|
dest_start: 39,
|
|
src_start: 0,
|
|
len: 15
|
|
},
|
|
]
|
|
}
|
|
]
|
|
)
|
|
)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse() {
|
|
let input = concat!(
|
|
"seeds: 79 14 55 13\n",
|
|
"\n",
|
|
"seed-to-soil map:\n",
|
|
"50 98 2\n",
|
|
"52 50 48\n",
|
|
"\n",
|
|
"soil-to-fertilizer map:\n",
|
|
"0 15 37\n",
|
|
"37 52 2\n",
|
|
"39 0 15\n",
|
|
"\n",
|
|
"fertilizer-to-water map:\n",
|
|
"49 53 8\n",
|
|
"0 11 42\n",
|
|
"42 0 7\n",
|
|
"57 7 4\n",
|
|
"\n",
|
|
"water-to-light map:\n",
|
|
"88 18 7\n",
|
|
"18 25 70\n",
|
|
"\n",
|
|
"light-to-temperature map:\n",
|
|
"45 77 23\n",
|
|
"81 45 19\n",
|
|
"68 64 13\n",
|
|
"\n",
|
|
"temperature-to-humidity map:\n",
|
|
"0 69 1\n",
|
|
"1 0 69\n",
|
|
"\n",
|
|
"humidity-to-location map:\n",
|
|
"60 56 37\n",
|
|
"56 93 4\n",
|
|
);
|
|
assert_eq!(
|
|
parse(input),
|
|
(
|
|
vec![79, 14, 55, 13],
|
|
vec![
|
|
Map {
|
|
from: "seed".to_string(),
|
|
to: "soil".to_string(),
|
|
ranges: vec![
|
|
MapRange {
|
|
dest_start: 50,
|
|
src_start: 98,
|
|
len: 2
|
|
},
|
|
MapRange {
|
|
dest_start: 52,
|
|
src_start: 50,
|
|
len: 48
|
|
}
|
|
]
|
|
},
|
|
Map {
|
|
from: "soil".to_string(),
|
|
to: "fertilizer".to_string(),
|
|
ranges: vec![
|
|
MapRange {
|
|
dest_start: 0,
|
|
src_start: 15,
|
|
len: 37
|
|
},
|
|
MapRange {
|
|
dest_start: 37,
|
|
src_start: 52,
|
|
len: 2
|
|
},
|
|
MapRange {
|
|
dest_start: 39,
|
|
src_start: 0,
|
|
len: 15
|
|
}
|
|
]
|
|
},
|
|
Map {
|
|
from: "fertilizer".to_string(),
|
|
to: "water".to_string(),
|
|
ranges: vec![
|
|
MapRange {
|
|
dest_start: 49,
|
|
src_start: 53,
|
|
len: 8
|
|
},
|
|
MapRange {
|
|
dest_start: 0,
|
|
src_start: 11,
|
|
len: 42
|
|
},
|
|
MapRange {
|
|
dest_start: 42,
|
|
src_start: 0,
|
|
len: 7
|
|
},
|
|
MapRange {
|
|
dest_start: 57,
|
|
src_start: 7,
|
|
len: 4
|
|
}
|
|
]
|
|
},
|
|
Map {
|
|
from: "water".to_string(),
|
|
to: "light".to_string(),
|
|
ranges: vec![
|
|
MapRange {
|
|
dest_start: 88,
|
|
src_start: 18,
|
|
len: 7
|
|
},
|
|
MapRange {
|
|
dest_start: 18,
|
|
src_start: 25,
|
|
len: 70
|
|
}
|
|
]
|
|
},
|
|
Map {
|
|
from: "light".to_string(),
|
|
to: "temperature".to_string(),
|
|
ranges: vec![
|
|
MapRange {
|
|
dest_start: 45,
|
|
src_start: 77,
|
|
len: 23
|
|
},
|
|
MapRange {
|
|
dest_start: 81,
|
|
src_start: 45,
|
|
len: 19
|
|
},
|
|
MapRange {
|
|
dest_start: 68,
|
|
src_start: 64,
|
|
len: 13
|
|
}
|
|
]
|
|
},
|
|
Map {
|
|
from: "temperature".to_string(),
|
|
to: "humidity".to_string(),
|
|
ranges: vec![
|
|
MapRange {
|
|
dest_start: 0,
|
|
src_start: 69,
|
|
len: 1
|
|
},
|
|
MapRange {
|
|
dest_start: 1,
|
|
src_start: 0,
|
|
len: 69
|
|
}
|
|
]
|
|
},
|
|
Map {
|
|
from: "humidity".to_string(),
|
|
to: "location".to_string(),
|
|
ranges: vec![
|
|
MapRange {
|
|
dest_start: 60,
|
|
src_start: 56,
|
|
len: 37
|
|
},
|
|
MapRange {
|
|
dest_start: 56,
|
|
src_start: 93,
|
|
len: 4
|
|
}
|
|
]
|
|
}
|
|
]
|
|
)
|
|
);
|
|
}
|
|
}
|