Fix warning about borrowing maps

Full context in this issue - rust-lang/rust#59159

It is currently a warning to borrow a map as mutable and then modify it.

Replacing such uses with the entry API.

src/day02.rs

@@ -17,10 +17,9 @@ fn character_counts(s: &str, n: usize) -> bool {
 fn counts(s: &str) -> HashMap<char, usize> {
     let mut result: HashMap<char, usize> = HashMap::new();
     for c in s.chars() {
-        match result.get(&c) {
-            Some(cur) => result.insert(c, cur + 1),
-            None => result.insert(c, 1),
-        };
+        result.entry(c)
+            .and_modify(|cur| *cur = *cur + 1)
+            .or_insert(1);
     }
     result
 }

src/day03.rs

@@ -55,10 +55,13 @@ fn count_dupes(big_cloth: &HashMap<(u32, u32), i32>) -> u32 {
 fn find_perfect(clothes: &[Cloth], big_cloth: &HashMap<(u32, u32), i32>) -> i32 {
     let mut successes = HashMap::new();
     big_cloth.values().filter(|x| **x > 0).for_each(|x| {
-        match successes.get(&x) {
-            Some(cur) => successes.insert(x, cur + 1),
-            None => successes.insert(x, 1),
-        };
+        successes.entry(x)
+            .and_modify(|cur| *cur = *cur + 1)
+            .or_insert(1);
+        // match successes.get(&x) {
+        //     Some(cur) => successes.insert(x, cur + 1),
+        //     None => successes.insert(x, 1),
+        // };
     });
     for cloth in clothes {
         match successes.get(&cloth.id) {

src/day04.rs

@@ -98,8 +98,8 @@ fn minute_most_often_asleep(naps: &[Nap]) -> (i32, i32) {
     }
     for nap in naps {
         for minute in nap.start.time().minute()..nap.end.time().minute() {
-            let cur = &minutes[&minute];
-            minutes.insert(minute, cur + 1);
+            minutes.entry(minute)
+                .and_modify(|cur| *cur = *cur + 1);
         }
     }
     let mut high_naps = 0;
@@ -130,14 +130,9 @@ fn process_logs(s: &str) -> HashMap<i32, Vec<Nap>> {
                     end: time,
                 };
                 let guard = current_guard.unwrap();
-                match guard_naps.get_mut(&guard) {
-                    Some(v) => {
-                        v.push(nap);
-                    }
-                    None => {
-                        guard_naps.insert(guard, vec![nap]);
-                    }
-                }
+                guard_naps.entry(guard)
+                    .or_default()
+                    .push(nap);
                 start_time = None;
             }
             Err(()) => panic!("error while parsing"),

src/day06.rs

@@ -53,13 +53,10 @@ impl Grid {
                 let nearest = tile.unwrap();
                 if self.is_edge(i, j) {
                     result.remove(&nearest);
-                }
-                let r = result.get(&nearest);
-                if r.is_none() {
                     continue;
                 }
-                let times = r.unwrap();
-                result.insert(nearest, times + 1);
+                result.entry(nearest)
+                    .and_modify(|times| *times = *times + 1);
             }
         }
         *result.values().max().unwrap()

src/day09.rs

@@ -30,10 +30,13 @@ impl Board {
             if marble % 23 == 0 {
                 current_index = (self.marbles.len() + current_index - 7) % self.marbles.len();
                 let score = marble + self.marbles.remove(current_index);
-                match self.scores.get(&current_player) {
-                    Some(n) => self.scores.insert(current_player, score + n),
-                    None => self.scores.insert(current_player, score),
-                };
+                self.scores.entry(current_player)
+                    .and_modify(|n| *n = *n + score)
+                    .or_insert(score);
+                // match self.scores.get(&current_player) {
+                //     Some(n) => self.scores.insert(current_player, score + n),
+                //     None => self.scores.insert(current_player, score),
+                // };
                 continue;
             }