Pruntado en Rust

Mi solvas per Rust la duan enigmon de Advent of Code. La enigmo estas sufiĉe simpla. La enigo aspektas jene:
mvgowxqubnhaefjslkjlrptzyi
pvgowlqubnhaefmslkjdrpteyi
ovgowoqubnhaefmslkjnrptzyi
cvgowxqubnrxefmslkjdrptzyo
cvgowxqubnhaefmsokjdrprzyf
cvgowxqubnhjeflslkjgrptzyi
...
La tasko:
...kalkulu, kiom da identigiloj enhavas iun ajn literon ekzakte dufoje, kaj aparte kalkulu tiujn, kiuj enhavas iun ajn literon ekzakte trifoje. Multiplikinte tiujn du nombrojn, vi ricevos [la respondon]...
Per pseŭdokodo la solvo aspektus proksimume jene:
for line in input
counters = count_letters(line)
seen_two_letters = 0
seen_three_letters = 0
for counter in counters
if counter.values.includes(2)
seen_two_letters += 1
if counter.values.include(3)
seen_three_letters += 1
print seen_two_letters * seen_three_letters
Nun en Rust. Sen speciala optimumigo mi konservos la nombrojn de signoj en ĉiu linio en vektoro de HashMap-oj. Poste mi trairos ilin kaj kalkulos la haŝtabelojn, kiuj havas 2 aŭ 3 inter siaj valoroj.
extern crate utils;
use std::collections::HashMap;
fn part_one() {
let input = utils::read_puzzle_input(2);
for line in input.lines() {
let mut counters: HashMap<char, u8> = HashMap::new();
for chr in line.chars() {
match counters.get(&chr).cloned() {
Some(count) => counters.insert(chr, count + 1),
None => counters.insert(chr, 1),
};
}
}
}
Mi lanĉas la kodon:
➜ aoc2018 git:(master) ✗ cargo run --bin 2
Compiling aoc2018 v0.1.0 (file:///Users/antono/Code/rust/aoc2018)
error[E0502]: cannot borrow `counters` as mutable because it is
also borrowed as immutable
--> src/bin/2.rs:57:32
|
56 | match counters.get(&chr) {
| -------- immutable borrow occurs here
57 | Some(count) => counters.insert(chr, count + 1),
| ^^^^^^^^ mutable borrow occurs here
58 | None => counters.insert(chr, 1),
59 | };
| - immutable borrow ends here
error[E0502]: cannot borrow `counters` as mutable because it is
also borrowed as immutable
--> src/bin/2.rs:58:25
|
56 | match counters.get(&chr) {
| -------- immutable borrow occurs here
57 | Some(count) => counters.insert(chr, count + 1),
58 | None => counters.insert(chr, 1),
| ^^^^^^^^ mutable borrow occurs here
59 | };
| - immutable borrow ends here
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0502`.
error: Could not compile `aoc2018`.
To learn more, run the command again with --verbose.
Mi relegas en la Rust Book la ĉapitrojn pri posedo kaj pruntado. La koncepto de posedo ŝajnis al mi klara. Sed pruntado, des pli ŝanĝebla pruntado, ne tiom. Por ĝuste prunti, oni devas obei kelkajn regulojn:
Unue, ĉiu prunto devas daŭri ne pli longe ol la videbleca amplekso (scope) de la posedanto. Due, vi povas havi aŭ unu aŭ la alian el tiuj du specoj de pruntoj, sed ne ambaŭ samtempe: unu aŭ plurajn referencojn (
&T) al rimedo, aŭ ekzakte unu ŝanĝeblan referencon (&mut T).
Do la problemo estas, ke mi pruntis la haŝtabelon counters samtempe por legado kaj por skribado. HashMap#get ja redonas Option kun referenco al la valoro (kiu troviĝas en la amaso, angle heap). Samtempe counter.insert() pruntas la datumojn de la haŝtabelo kiel ŝanĝeblajn, por modifi ilin (ankaŭ en la amaso). Rust tion malpermesas por garantii memorsekurecon kaj eviti konkurkondiĉojn (race conditions):
Posedo estas la maniero, per kiu Rust atingas sian plej grandan celon: memorsekurecon.
Unu el la manieroj eviti pruntadon de la valoro por legado estas simple kopii ĝin. La dokumentaro de Option proponas la utilan metodon .cloned().
Transformas
Option<&T>enOption<T>, klonante la enhavon de la Option.
Mi uzos tiun metodon, kiam mi prenas valoron el la haŝtabelo:
fn part_one() {
let input = utils::read_puzzle_input(2);
for line in input.lines() {
let mut counters: HashMap<char, u8> = HashMap::new();
for chr in line.chars() {
match counters.get(&chr).cloned() {
Some(count) => counters.insert(chr, count + 1),
None => counters.insert(chr, 1),
};
}
println!("{:?}", counters.values());
}
}
Mi lanĉas la kodon:
cargo run --bin 2
Compiling aoc2018 v0.1.0 (file:///Users/antono/Code/rust/aoc2018)
Finished dev [unoptimized + debuginfo] target(s) in 0.62 secs
Running `target/debug/2`
[1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1]
[1, 1, 1, 2, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1]
[1, 1, 2, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2]
[1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2]
[1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 1]
...
Funkcias! La sola ĝeno: mi devas ĉiufoje kopii la valoron nur por eviti nurlegan pruntadon. Iu saĝulo konsilis al mi uzi HashMap#entry(), kiu donas Entry por modifi la valoron en la haŝtabelo surloke. Entry mem havas multajn utilajn metodojn. Entry#and_modify() ŝajnas ĝuste tio, kion mi bezonas. Ekzemplo el la dokumentaro:
use std::collections::HashMap;
let mut map: HashMap<&str, u32> = HashMap::new();
map.entry("poneyland")
.and_modify(|e| { *e += 1 })
.or_insert(42);
assert_eq!(map["poneyland"], 42);
Ŭaŭ! Mi ŝanĝas mian kodon de ĉi tio:
for line in input.lines() {
let mut counters: HashMap<char, u8> = HashMap::new();
for chr in line.chars() {
match counters.get(&chr).cloned() {
Some(count) => counters.insert(chr, count + 1),
None => counters.insert(chr, 1),
};
}
}
al ĉi tio:
for line in input.lines() {
let mut counters: HashMap<char, u8> = HashMap::new();
for chr in line.chars() {
counters
.entry(chr)
.and_modify(|count| { *count += 1})
.or_insert(1);
}
}
Bone. Estas tempo fini la AOC-enigmon. Mi kalkulis ĉiujn literojn en ĉiuj identigiloj. Nun restas kalkuli jenon:
...kalkulu, kiom da identigiloj enhavas iun ajn literon ekzakte dufoje, kaj aparte kalkulu tiujn, kiuj enhavas iun ajn literon ekzakte trifoje. Multiplikinte tiujn du nombrojn, vi ricevos [la respondon]...
# pseudocode
seen_two_letters = 0
seen_three_letters = 0
for counter in counters
if counter.values.includes(2)
seen_two_letters += 1
if counter.values.include(3)
seen_three_letters += 1
print seen_two_letters * seen_three_letters
Nun la sama en Rust:
extern crate utils;
use std::collections::HashMap;
fn part_one() {
let input = utils::read_puzzle_input(2);
let mut seen_two_letters_count = 0;
let mut seen_three_letters_count = 0;
for line in input.lines() {
let mut counter: HashMap<char, u8> = HashMap::new();
for chr in line.chars() {
counter
.entry(chr)
.and_modify(|count| { *count += 1})
.or_insert(1);
}
if counter.values().find(|v| { **v == 2 }).is_some() {
seen_two_letters_count += 1;
}
if counter.values().find(|v| { **v == 3 }).is_some() {
seen_three_letters_count += 1;
}
}
println!("{}", seen_three_letters_count * seen_two_letters_count);
}
Lanĉo:
➜ aoc2018 git:(master) ✗ cargo run --bin 2
Compiling aoc2018 v0.1.0 (file:///Users/antono/Code/rust/aoc2018)
Finished dev [unoptimized + debuginfo] target(s) in 0.62 secs
Running `target/debug/2`
5368
La nombro estas akceptita!
Via respondo estis
5368. La unua duono de la enigmo estas solvita! Ĝi donas unu oran stelon: *