quickdudley/adventofcode - Change MWTAS2BIIR4LYXIVGASOR52XQXKCUCTQNB4MO4WSSTBI4BSG7HKAC

cargo fmt

Created by quickdudley on December 2, 2021

MWTAS2BIIR4LYXIVGASOR52XQXKCUCTQNB4MO4WSSTBI4BSG7HKAC

Dependencies

In channels

main

Change contents

Deletion in 2020/day7.rs at line 1 [5.1481]
B:BD[5.1481] → [5.1482:1505]
```
use std::str::FromStr;
```
Insertion in 2020/day7.rs at line 2 [5.1481]
[5.1534]
[5.1534]
```
use std::str::FromStr;
```
Replacement in 2020/day7.rs at line 6 [5.1481]
B:BD[5.1568] → [5.1568:1597]
```
    inner: Vec<(String,u8)>,
```
[5.1568]
[5.1597]
```
    inner: Vec<(String, u8)>,
```
Replacement in 2020/day7.rs at line 9 [5.1481]
B:BD[5.1600] → [5.1600:1623]
```
#[derive(Debug,Clone)]
```
[5.1600]
[5.1623]
```
#[derive(Debug, Clone)]
```

Replacement in 2020/day7.rs at line 34 [5.1481]

B:BD[5.2165] → [5.2165:2271]

        let outer = Intercalate::new(outer.iter(), &" ").map(std::ops::Deref::deref).collect::<String>();

[5.2165]

[5.2271]

        let outer = Intercalate::new(outer.iter(), &" ")
            .map(std::ops::Deref::deref)
            .collect::<String>();

Replacement in 2020/day7.rs at line 45 [5.1481]

B:BD[5.2544] → [5.2544:3104]

                Some(w) => if w == "no" {
                   match words.next() {
                       Some("other") => Ok(()),
                       _ => Err(RuleParseError::Other),
                   }?;
                   match words.next() {
                       Some("bags.") => Ok(()),
                       _ => Err(RuleParseError::Other),
                   }?;
                   return Ok(Rule {outer: outer, inner: inner});
                } else {
                    w.parse().or_else(|e| Err(RuleParseError::Numeric(e)))
                },

[5.2544]

[5.3104]

                Some(w) => {
                    if w == "no" {
                        match words.next() {
                            Some("other") => Ok(()),
                            _ => Err(RuleParseError::Other),
                        }?;
                        match words.next() {
                            Some("bags.") => Ok(()),
                            _ => Err(RuleParseError::Other),
                        }?;
                        return Ok(Rule {
                            outer: outer,
                            inner: inner,
                        });
                    } else {
                        w.parse().or_else(|e| Err(RuleParseError::Numeric(e)))
                    }
                }

Replacement in 2020/day7.rs at line 67 [5.1481]

B:BD[5.3278] → [5.3278:3405]

                    inner.push((Intercalate::new(color.iter(), &" ").map(std::ops::Deref::deref).collect::<String>(), count));

[5.3278]

[5.3405]

                    inner.push((
                        Intercalate::new(color.iter(), &" ")
                            .map(std::ops::Deref::deref)
                            .collect::<String>(),
                        count,
                    ));

Replacement in 2020/day7.rs at line 74 [5.1481]

B:BD[5.3465] → [5.3465:3537]

                        return Ok(Rule { outer: outer, inner: inner });

[5.3465]

[5.3537]

                        return Ok(Rule {
                            outer: outer,
                            inner: inner,
                        });

Replacement in 2020/day7.rs at line 97 [5.1481]

B:BD[5.3949] → [5.3949:4018]

        Self { sep: sep, inner: inner.peekable(), sep_phase: false }

[5.3949]

[5.4018]

        Self {
            sep: sep,
            inner: inner.peekable(),
            sep_phase: false,
        }

Replacement in 2020/day7.rs at line 105 [5.1481]

B:BD[5.4027] → [5.4027:4096]

impl<I: Iterator> Iterator for Intercalate<I> where I::Item: Clone {

[5.4027]

[5.4096]

impl<I: Iterator> Iterator for Intercalate<I>
where
    I::Item: Clone,
{

Replacement in 2020/day7.rs at line 117 [5.1481]

B:BD[5.4351] → [5.4351:4399]

                },
                None => None

[5.4351]

[5.4399]

                }
                None => None,

Replacement in 2020/day7.rs at line 132 [5.1481]

B:BD[5.4734] → [5.4734:4864]

        for (inner,_) in rule.inner.iter() {
            flowback.entry(inner).or_insert_with(Vec::new).push(rule.outer.clone());

[5.4734]

[5.4864]

        for (inner, _) in rule.inner.iter() {
            flowback
                .entry(inner)
                .or_insert_with(Vec::new)
                .push(rule.outer.clone());

Replacement in 2020/day7.rs at line 152 [5.1481]
B:BD[5.5342] → [5.5342:5357]
```
            },
```
[5.5342]
[5.5357]
```
            }
```
Replacement in 2020/day7.rs at line 154 [5.1481]
B:BD[5.5367] → [5.5367:5374]
```
    };
```
[5.5367]
[5.5374]
```
    }
```

Replacement in 2020/day7.rs at line 163 [5.1481]

B:BD[5.5558] → [5.5558:5725]

    let mut counted: HashMap<String,usize> = HashMap::new();
    let tree: HashMap<_,_> = rules.iter().map(|rule| (rule.outer.clone(), rule.inner.clone())).collect();

[5.5558]

[5.5725]

    let mut counted: HashMap<String, usize> = HashMap::new();
    let tree: HashMap<_, _> = rules
        .iter()
        .map(|rule| (rule.outer.clone(), rule.inner.clone()))
        .collect();

Replacement in 2020/day7.rs at line 174 [5.1481]

B:BD[5.5902] → [5.5902:6675]

                None => if tree
                    .get(&c)
                    .iter()
                    .flat_map(|v| v.iter()).all(|(r,_)|
                        counted.contains_key(r)
                ) {
                    counted.insert(c.clone(), tree
                                   .get(&c)
                                   .iter()
                                   .flat_map(|v| v.iter())
                                   .map(|(r,n)|
                                        (1 + counted
                                         .get(r)
                                         .map(|x| *x)
                                         .unwrap_or(0)
                                         ) * usize::from(*n)
                                   ).sum()

[5.5902]

[5.6675]

                None => {
                    if tree
                        .get(&c)
                        .iter()
                        .flat_map(|v| v.iter())
                        .all(|(r, _)| counted.contains_key(r))
                    {
                        counted.insert(
                            c.clone(),
                            tree.get(&c)
                                .iter()
                                .flat_map(|v| v.iter())
                                .map(|(r, n)| {
                                    (1 + counted.get(r).map(|x| *x).unwrap_or(0)) * usize::from(*n)
                                })
                                .sum(),

Replacement in 2020/day7.rs at line 191 [5.1481]

B:BD[5.6702] → [5.6702:6886]

                } else {
                    q.push(c.clone());
                    for (r,_) in tree.get(&c).iter().flat_map(|v| v.iter()) {
                        q.push(r.clone())

[5.6702]

[5.6886]

                    } else {
                        q.push(c.clone());
                        for (r, _) in tree.get(&c).iter().flat_map(|v| v.iter()) {
                            q.push(r.clone())
                        }

Replacement in 2020/day7.rs at line 197 [5.1481]
B:BD[5.6908] → [5.6908:6927]
```
                },
```
[5.6908]
[5.6927]
```
                }
```
Replacement in 2020/day7.rs at line 200 [5.1481]
B:BD[5.6952] → [5.6952:6959]
```
    };
```
[5.6952]
[5.6959]
```
    }
```

Replacement in 2020/day7.rs at line 217 [5.1481]

B:BD[5.7358] → [5.7358:7596]

    println!("{}", match args[2].as_ref() {
        "1" => count_colors_containing(rules, vec![String::from("shiny gold")]),
        "2" => count_bags_in(rules, String::from("shiny gold")),
        _ => panic!("No such problem"),
    });

[5.7358]

[5.7596]

    println!(
        "{}",
        match args[2].as_ref() {
            "1" => count_colors_containing(rules, vec![String::from("shiny gold")]),
            "2" => count_bags_in(rules, String::from("shiny gold")),
            _ => panic!("No such problem"),
        }
    );

Deletion in 2020/day7.rs at line 226 [5.1481]
B:BD[5.7598] → [5.7598:7599]

Replacement in 2020/day6.rs at line 13 [4.10]

B:BD[4.189] → [4.189:261]

impl<I: Iterator<Item=S>, S: AsRef<str>> Iterator for GroupedLines<I> {

[4.189]

[4.261]

impl<I: Iterator<Item = S>, S: AsRef<str>> Iterator for GroupedLines<I> {

Replacement in 2020/day6.rs at line 25 [4.10]
B:BD[4.638] → [4.638:657]
```
                },
```
[4.638]
[4.657]
```
                }
```
Replacement in 2020/day6.rs at line 28 [4.10]
B:BD[4.702] → [4.702:713]
```
        };
```
[4.702]
[4.713]
```
        }
```

Replacement in 2020/day6.rs at line 48 [4.10]

B:BD[4.1165] → [4.1165:1251]

                r = r.intersection(&l.chars().collect()).map(Clone::clone).collect();

[4.1165]

[4.1251]

                r = r
                    .intersection(&l.chars().collect())
                    .map(Clone::clone)
                    .collect();

Replacement in 2020/day6.rs at line 54 [4.10]
B:BD[4.1279] → [4.1279:1290]
```
        },
```
[4.1279]
[4.1290]
```
        }
```

Replacement in 2020/day6.rs at line 63 [4.10]

B:BD[4.1444] → [4.1444:1760]

        std::io::BufReader::new(std::fs::File::open(&args[1]).unwrap()).lines()
        .map(Result::unwrap)
        ).map(match args[2].as_ref() {
            "any" => any_checked,
            "all" => all_checked,
            _ => panic!("No such aggregator"),
        })
        .map(|c| c.len())
        .sum();

[4.1444]

[4.1760]

        std::io::BufReader::new(std::fs::File::open(&args[1]).unwrap())
            .lines()
            .map(Result::unwrap),
    )
    .map(match args[2].as_ref() {
        "any" => any_checked,
        "all" => all_checked,
        _ => panic!("No such aggregator"),
    })
    .map(|c| c.len())
    .sum();

Deletion in 2020/day6.rs at line 76 [4.10]
B:BD[4.1790] → [4.1790:1791]

Replacement in 2020/day5.rs at line 3 [5.10]

B:BD[5.39] → [5.39:106]

fn find_seat<I: Iterator<Item=char>>(source: &mut I) -> (u8, u8) {

[5.39]

[5.106]

fn find_seat<I: Iterator<Item = char>>(source: &mut I) -> (u8, u8) {

Replacement in 2020/day5.rs at line 8 [5.10]

B:BD[5.188] → [5.188:342]

            'F' => { row *= 2; },
            'B' => { row = row * 2 + 1; },
            'L' => { col *= 2; },
            'R' => { col = col * 2 + 1; },

[5.188]

[5.342]

            'F' => {
                row *= 2;
            }
            'B' => {
                row = row * 2 + 1;
            }
            'L' => {
                col *= 2;
            }
            'R' => {
                col = col * 2 + 1;
            }

Replacement in 2020/day5.rs at line 23 [5.10]
B:BD[5.379] → [5.379:393]
```
    (row,col)
```
[5.379]
[5.393]
```
    (row, col)
```

Replacement in 2020/day5.rs at line 30 [5.10]

B:BD[5.477] → [5.477:534]

fn max_seat<I: Iterator<Item=u16>>(ids: &mut I) -> u16 {

[5.477]

[5.534]

fn max_seat<I: Iterator<Item = u16>>(ids: &mut I) -> u16 {

Replacement in 2020/day5.rs at line 34 [5.10]

B:BD[5.560] → [5.560:616]

fn my_seat<I: Iterator<Item=u16>>(ids: &mut I) -> u16 {

[5.560]

[5.616]

fn my_seat<I: Iterator<Item = u16>>(ids: &mut I) -> u16 {

Replacement in 2020/day5.rs at line 39 [5.10]

B:BD[5.770] → [5.770:822]

    };
    for (i,f) in filled.iter().enumerate() {

[5.770]

[5.822]

    }
    for (i, f) in filled.iter().enumerate() {

Replacement in 2020/day5.rs at line 54 [5.10]

B:BD[5.1209] → [5.1209:1269]

        let (row,col) = find_seat(&mut l.unwrap().chars());

[5.1209]

[5.1269]

        let (row, col) = find_seat(&mut l.unwrap().chars());

Replacement in 2020/day5.rs at line 57 [5.10]

B:BD[5.1303] → [5.1303:1468]

    println!("{}", match args[2].as_ref() {
        "1" => max_seat(&mut seats),
        "2" => my_seat(&mut seats),
        _ => panic!("unknown problem"),
    });

[5.1303]

[5.1468]

    println!(
        "{}",
        match args[2].as_ref() {
            "1" => max_seat(&mut seats),
            "2" => my_seat(&mut seats),
            _ => panic!("unknown problem"),
        }
    );

Replacement in 2020/day4.rs at line 4 [3.10]

B:BD[3.57] → [3.57:123]

fn extract_keys<S: AsRef<str>>(ln: S) -> HashMap<String,String> {

[3.57]

[3.123]

fn extract_keys<S: AsRef<str>>(ln: S) -> HashMap<String, String> {

Replacement in 2020/day4.rs at line 9 [3.10]
B:BD[3.343] → [3.343:350]
```
    };
```
[3.343]
[3.350]
```
    }
```

Replacement in 2020/day4.rs at line 13 [3.10]

B:BD[3.367] → [3.367:624]

const REQUIRED: &[(&str, fn(String) -> bool)] =
    &[
        ("byr", check_byr),
        ("iyr", check_iyr),
        ("eyr", check_eyr),
        ("hgt", check_hgt),
        ("hcl", check_hcl),
        ("ecl", check_ecl),
        ("pid", check_pid)
    ];

[3.367]

[3.624]

const REQUIRED: &[(&str, fn(String) -> bool)] = &[
    ("byr", check_byr),
    ("iyr", check_iyr),
    ("eyr", check_eyr),
    ("hgt", check_hgt),
    ("hcl", check_hcl),
    ("ecl", check_ecl),
    ("pid", check_pid),
];

Replacement in 2020/day4.rs at line 24 [3.10]

B:BD[3.660] → [3.660:790]

    ln.len() == 4 && match ln.parse::<usize>() {
        Ok(year) => year >= 1920 && year <= 2002,
        Err(_) => false,
    }

[3.660]

[3.790]

    ln.len() == 4
        && match ln.parse::<usize>() {
            Ok(year) => year >= 1920 && year <= 2002,
            Err(_) => false,
        }

Replacement in 2020/day4.rs at line 32 [3.10]

B:BD[3.828] → [3.828:958]

    ln.len() == 4 && match ln.parse::<usize>() {
        Ok(year) => year >= 2010 && year <= 2020,
        Err(_) => false,
    }

[3.828]

[3.958]

    ln.len() == 4
        && match ln.parse::<usize>() {
            Ok(year) => year >= 2010 && year <= 2020,
            Err(_) => false,
        }

Replacement in 2020/day4.rs at line 40 [3.10]

B:BD[3.996] → [3.996:1126]

    ln.len() == 4 && match ln.parse::<usize>() {
        Ok(year) => year >= 2020 && year <= 2030,
        Err(_) => false,
    }

[3.996]

[3.1126]

    ln.len() == 4
        && match ln.parse::<usize>() {
            Ok(year) => year >= 2020 && year <= 2030,
            Err(_) => false,
        }

Replacement in 2020/day4.rs at line 60 [3.10]
B:BD[3.1612] → [3.1612:1631]
```
                },
```
[3.1612]
[3.1631]
```
                }
```
Replacement in 2020/day4.rs at line 63 [3.10]
B:BD[3.1678] → [3.1678:1690]
```
        },
```
[3.1678]
[3.1690]
```
        }
```

Replacement in 2020/day4.rs at line 85 [3.10]

B:BD[3.2033] → [3.2033:2100]

    for ex in ["amb","blu","brn","gry","grn","hzl","oth"].iter() {

[3.2033]

[3.2100]

    for ex in ["amb", "blu", "brn", "gry", "grn", "hzl", "oth"].iter() {

Replacement in 2020/day4.rs at line 97 [3.10]
B:BD[3.2271] → [3.2271:2299]
```
#[derive(Clone,Copy,Debug)]
```
[3.2271]
[3.2299]
```
#[derive(Clone, Copy, Debug)]
```
Replacement in 2020/day4.rs at line 99 [3.10]
B:BD[3.2315] → [3.2315:2350]
```
  Passport,
  NorthPole,
  Invalid
```
[3.2315]
[3.2350]
```
    Passport,
    NorthPole,
    Invalid,
```
Replacement in 2020/day4.rs at line 105 [3.10]
B:BD[3.2378] → [3.2378:2390]
```
  inner: I,
```
[3.2378]
[3.2390]
```
    inner: I,
```

Replacement in 2020/day4.rs at line 114 [3.10]

B:BD[3.2497] → [3.2497:2648]

impl<I: Iterator<Item=HashMap<Q,R>>, Q: Clone + std::cmp::Eq + std::hash::Hash, R: Clone> Iterator for DelimByEmpty<I> {
    type Item = HashMap<Q,R>;

[3.2497]

[3.2648]

impl<I: Iterator<Item = HashMap<Q, R>>, Q: Clone + std::cmp::Eq + std::hash::Hash, R: Clone>
    Iterator for DelimByEmpty<I>
{
    type Item = HashMap<Q, R>;

Replacement in 2020/day4.rs at line 129 [3.10]
B:BD[3.2992] → [3.2992:3011]
```
                },
```
[3.2992]
[3.3011]
```
                }
```

Replacement in 2020/day4.rs at line 134 [3.10]

B:BD[3.3158] → [3.3158:3213]

                        for (key,val) in line.iter() {

[3.3158]

[3.3213]

                        for (key, val) in line.iter() {

Replacement in 2020/day4.rs at line 138 [3.10]
B:BD[3.3330] → [3.3330:3349]
```
                },
```
[3.3330]
[3.3349]
```
                }
```

Replacement in 2020/day4.rs at line 144 [3.10]

B:BD[3.3382] → [3.3382:3505]

fn validate_line(found: HashMap<String,String>, version: usize) -> Document {
    for (key,validator) in REQUIRED.iter() {

[3.3382]

[3.3505]

fn validate_line(found: HashMap<String, String>, version: usize) -> Document {
    for (key, validator) in REQUIRED.iter() {

Replacement in 2020/day4.rs at line 147 [3.10]

B:BD[3.3552] → [3.3552:3603]

            None => { return Document::Invalid; },

[3.3552]

[3.3603]

            None => {
                return Document::Invalid;
            }

Replacement in 2020/day4.rs at line 154 [3.10]
B:BD[3.3759] → [3.3759:3774]
```
            },
```
[3.3759]
[3.3774]
```
            }
```
Replacement in 2020/day4.rs at line 156 [3.10]
B:BD[3.3784] → [3.3784:3791]
```
    };
```
[3.3784]
[3.3791]
```
    }
```

Replacement in 2020/day4.rs at line 172 [3.10]

B:BD[3.4220] → [3.4220:4434]

            .map(extract_keys)
        ).map(|d| validate_line(d, version))
        .map(|t| match t {
            Document::Invalid => 0,
            _ => 1,
        })
        .sum();
    println!("{:}",result);

[3.4220]

[3.4434]

            .map(extract_keys),
    )
    .map(|d| validate_line(d, version))
    .map(|t| match t {
        Document::Invalid => 0,
        _ => 1,
    })
    .sum();
    println!("{:}", result);

Deletion in 2020/day4.rs at line 182 [3.10]
B:BD[3.4436] → [3.4436:4437]
Replacement in 2020/day3.rs at line 4 [2.10]
B:BD[2.48] → [2.48:76]
```
#[derive(Debug,Copy,Clone)]
```
[2.48]
[2.76]
```
#[derive(Debug, Copy, Clone)]
```
Replacement in 2020/day3.rs at line 16 [2.10]
B:BD[2.197] → [2.197:229]
```
        Pairs { inner: inner, }
```
[2.197]
[2.229]
```
        Pairs { inner: inner }
```
Replacement in 2020/day3.rs at line 21 [2.10]
B:BD[2.268] → [2.268:288]
```
where I: Iterator {
```
[2.268]
[2.288]
```
where
    I: Iterator,
{
```
Replacement in 2020/day3.rs at line 28 [2.10]
B:BD[2.471] → [2.471:491]
```
        Some((a,b))
```
[2.471]
[2.491]
```
        Some((a, b))
```

Replacement in 2020/day3.rs at line 36 [2.10]

B:BD[2.596] → [2.596:637]

        _ => panic!("Unrecognized tile")

[2.596]

[2.637]

        _ => panic!("Unrecognized tile"),

Replacement in 2020/day3.rs at line 45 [2.10]

B:BD[2.831] → [2.831:903]

            Tile::Blank => {},
            Tile::Tree => {count += 1;},

[2.831]

[2.903]

            Tile::Blank => {}
            Tile::Tree => {
                count += 1;
            }

Replacement in 2020/day3.rs at line 60 [2.10]

B:BD[2.1149] → [2.1149:1253]

        .map(|l| l
             .chars()
             .map(tile)
             .collect()
             )

[2.1149]

[2.1253]

        .map(|l| l.chars().map(tile).collect())

Replacement in 2020/day3.rs at line 62 [2.10]

B:BD[2.1273] → [2.1273:1416]

    let slopes: Vec<(usize,usize)> = Pairs::new(args[2]
        .split(",")
        .map(|s| s.parse::<usize>().unwrap())
        ).collect();

[2.1273]

[2.1416]

    let slopes: Vec<(usize, usize)> =
        Pairs::new(args[2].split(",").map(|s| s.parse::<usize>().unwrap())).collect();

Replacement in 2020/day3.rs at line 65 [2.10]

B:BD[2.1417] → [2.1417:1553]

    println!("{}", slopes.iter()
             .map(|(dx,dy)| trees_hit(&grid, *dx, *dy))
             .product::<u64>()
             );

[2.1417]

[2.1553]

    println!(
        "{}",
        slopes
            .iter()
            .map(|(dx, dy)| trees_hit(&grid, *dx, *dy))
            .product::<u64>()
    );

Replacement in 2020/day15.rs at line 31 [8.11]

B:BD[8.570] → [8.570:617]

        let nxt = self.history.get(&self.last)

[8.570]

[8.617]

        let nxt = self
            .history
            .get(&self.last)

Deletion in 2020/day15.rs at line 41 [8.11]
B:BD[8.730] → [8.730:784]
```
    use std::io::BufReader;
    use std::io::BufRead;
```

Insertion in 2020/day15.rs at line 42 [8.11]

[8.807]

    use std::io::BufRead;
    use std::io::BufReader;

Replacement in 2020/day15.rs at line 50 [8.11]

B:BD[8.1070] → [8.1070:1193]

        match <usize as FromStr>::from_str(String::from_utf8(strnum.unwrap_or(vec![])).unwrap_or("".to_string()).trim()) {

[8.1070]

[8.1193]

        match <usize as FromStr>::from_str(
            String::from_utf8(strnum.unwrap_or(vec![]))
                .unwrap_or("".to_string())
                .trim(),
        ) {

Replacement in 2020/day15.rs at line 58 [8.11]
B:BD[8.1262] → [8.1262:1287]
```
            Err(_) => ()
```
[8.1262]
[8.1287]
```
            Err(_) => (),
```
Replacement in 2020/day12.rs at line 3 [7.11]
B:BD[7.36] → [7.36:71]
```
#[derive(Clone,Copy,PartialEq,Eq)]
```
[7.36]
[7.71]
```
#[derive(Clone, Copy, PartialEq, Eq)]
```
Replacement in 2020/day12.rs at line 8 [7.11]
B:BD[7.108] → [7.108:114]
```
    W
```
[7.108]
[7.114]
```
    W,
```
Replacement in 2020/day12.rs at line 11 [7.11]
B:BD[7.117] → [7.117:152]
```
#[derive(Clone,Copy,PartialEq,Eq)]
```
[7.117]
[7.152]
```
#[derive(Clone, Copy, PartialEq, Eq)]
```
Replacement in 2020/day12.rs at line 13 [7.11]
B:BD[7.169] → [7.169:190]
```
    C(Cardinal,u16),
```
[7.169]
[7.190]
```
    C(Cardinal, u16),
```
Replacement in 2020/day12.rs at line 47 [7.11]
B:BD[7.1014] → [7.1014:1050]
```
        let (c,ns) = s.split_at(1);
```
[7.1014]
[7.1050]
```
        let (c, ns) = s.split_at(1);
```

Replacement in 2020/day12.rs at line 51 [7.11]

B:BD[7.1133] → [7.1133:1196]

                Ok(Direction::C(Cardinal::N,d))
            },

[7.1133]

[7.1196]

                Ok(Direction::C(Cardinal::N, d))
            }

Replacement in 2020/day12.rs at line 55 [7.11]

B:BD[7.1261] → [7.1261:1324]

                Ok(Direction::C(Cardinal::S,d))
            },

[7.1261]

[7.1324]

                Ok(Direction::C(Cardinal::S, d))
            }

Replacement in 2020/day12.rs at line 59 [7.11]

B:BD[7.1389] → [7.1389:1452]

                Ok(Direction::C(Cardinal::E,d))
            },

[7.1389]

[7.1452]

                Ok(Direction::C(Cardinal::E, d))
            }

Replacement in 2020/day12.rs at line 63 [7.11]

B:BD[7.1517] → [7.1517:1580]

                Ok(Direction::C(Cardinal::W,d))
            },

[7.1517]

[7.1580]

                Ok(Direction::C(Cardinal::W, d))
            }

Replacement in 2020/day12.rs at line 68 [7.11]
B:BD[7.1706] → [7.1706:1721]
```
            },
```
[7.1706]
[7.1721]
```
            }
```
Replacement in 2020/day12.rs at line 72 [7.11]
B:BD[7.1841] → [7.1841:1856]
```
            },
```
[7.1841]
[7.1856]
```
            }
```
Replacement in 2020/day12.rs at line 76 [7.11]
B:BD[7.1957] → [7.1957:1972]
```
            },
```
[7.1957]
[7.1972]
```
            }
```
Replacement in 2020/day12.rs at line 82 [7.11]
B:BD[7.2064] → [7.2064:2099]
```
#[derive(Clone,Copy,PartialEq,Eq)]
```
[7.2064]
[7.2099]
```
#[derive(Clone, Copy, PartialEq, Eq)]
```

Replacement in 2020/day12.rs at line 93 [7.11]

B:BD[7.2240] → [7.2240:2321]

        Ship {x: 0, y: 0, bearing: Cardinal::E, waypoint_x: 10, waypoint_y: -1 }

[7.2240]

[7.2321]

        Ship {
            x: 0,
            y: 0,
            bearing: Cardinal::E,
            waypoint_x: 10,
            waypoint_y: -1,
        }

Replacement in 2020/day12.rs at line 105 [7.11]

B:BD[7.2429] → [7.2429:2752]

                Direction::C(c,d) => match c {
                    Cardinal::N => { self.waypoint_y -= d as i32; },
                    Cardinal::S => { self.waypoint_y += d as i32; },
                    Cardinal::E => { self.waypoint_x += d as i32; },
                    Cardinal::W => { self.waypoint_x -= d as i32; },

[7.2429]

[7.2752]

                Direction::C(c, d) => match c {
                    Cardinal::N => {
                        self.waypoint_y -= d as i32;
                    }
                    Cardinal::S => {
                        self.waypoint_y += d as i32;
                    }
                    Cardinal::E => {
                        self.waypoint_x += d as i32;
                    }
                    Cardinal::W => {
                        self.waypoint_x -= d as i32;
                    }

Replacement in 2020/day12.rs at line 120 [7.11]

B:BD[7.2822] → [7.2822:2851]

                    0 => {},

[7.2822]

[7.2851]

                    0 => {}

Replacement in 2020/day12.rs at line 122 [7.11]

B:BD[7.2878] → [7.2878:2950]

                        let (x,y) = (self.waypoint_x, self.waypoint_y);

[7.2878]

[7.2950]

                        let (x, y) = (self.waypoint_x, self.waypoint_y);

Replacement in 2020/day12.rs at line 125 [7.11]
B:BD[7.3041] → [7.3041:3064]
```
                    },
```
[7.3041]
[7.3064]
```
                    }
```

Replacement in 2020/day12.rs at line 127 [7.11]

B:BD[7.3091] → [7.3091:3163]

                        let (x,y) = (self.waypoint_x, self.waypoint_y);

[7.3091]

[7.3163]

                        let (x, y) = (self.waypoint_x, self.waypoint_y);

Replacement in 2020/day12.rs at line 130 [7.11]
B:BD[7.3255] → [7.3255:3278]
```
                    },
```
[7.3255]
[7.3278]
```
                    }
```

Replacement in 2020/day12.rs at line 132 [7.11]

B:BD[7.3305] → [7.3305:3377]

                        let (x,y) = (self.waypoint_x, self.waypoint_y);

[7.3305]

[7.3377]

                        let (x, y) = (self.waypoint_x, self.waypoint_y);

Replacement in 2020/day12.rs at line 135 [7.11]
B:BD[7.3468] → [7.3468:3491]
```
                    },
```
[7.3468]
[7.3491]
```
                    }
```
Replacement in 2020/day12.rs at line 141 [7.11]
B:BD[7.3715] → [7.3715:3734]
```
                },
```
[7.3715]
[7.3734]
```
                }
```

Replacement in 2020/day12.rs at line 145 [7.11]

B:BD[7.3789] → [7.3789:4076]

                Direction::C(c,d) => match c {
                    Cardinal::N => { self.y -= d as i32; },
                    Cardinal::S => { self.y += d as i32; },
                    Cardinal::E => { self.x += d as i32; },
                    Cardinal::W => { self.x -= d as i32; },

[7.3789]

[7.4076]

                Direction::C(c, d) => match c {
                    Cardinal::N => {
                        self.y -= d as i32;
                    }
                    Cardinal::S => {
                        self.y += d as i32;
                    }
                    Cardinal::E => {
                        self.x += d as i32;
                    }
                    Cardinal::W => {
                        self.x -= d as i32;
                    }

Replacement in 2020/day12.rs at line 173 [7.11]
B:BD[7.4686] → [7.4686:4705]
```
                },
```
[7.4686]
[7.4705]
```
                }
```

Replacement in 2020/day12.rs at line 184 [7.11]

B:BD[7.4943] → [7.4943:5067]

    let file = std::io::BufReader::new(std::fs::File::open(<String as AsRef<std::path::Path>>::as_ref(&args[1])).unwrap());

[7.4943]

[7.5067]

    let file = std::io::BufReader::new(
        std::fs::File::open(<String as AsRef<std::path::Path>>::as_ref(&args[1])).unwrap(),
    );

Replacement in 2020/day12.rs at line 190 [7.11]

B:BD[7.5153] → [7.5153:5209]

        _ => panic!("Version number (1 or 2) expected")

[7.5153]

[7.5209]

        _ => panic!("Version number (1 or 2) expected"),

Replacement in 2020/day11.rs at line 4 [9.11]
B:BD[9.54] → [9.54:78]
```
#[derive(PartialEq,Eq)]
```
[9.54]
[9.78]
```
#[derive(PartialEq, Eq)]
```

Replacement in 2020/day11.rs at line 21 [9.11]

B:BD[9.319] → [9.319:538]

fn neighbours(xc: usize, yc: usize) -> impl Iterator<Item=(isize,isize)> {
    (-1 .. 2).flat_map(|y| (-1 .. 2).map(move |x| (x,y))).filter(|p| *p != (0,0))
        .map(move |(x,y)| (x + xc as isize, y + yc as isize))

[9.319]

[9.538]

fn neighbours(xc: usize, yc: usize) -> impl Iterator<Item = (isize, isize)> {
    (-1..2)
        .flat_map(|y| (-1..2).map(move |x| (x, y)))
        .filter(|p| *p != (0, 0))
        .map(move |(x, y)| (x + xc as isize, y + yc as isize))

Replacement in 2020/day11.rs at line 28 [9.11]

B:BD[9.541] → [6.0:966]

fn build_neighbourhoods_v1(grid: &Vec<Vec<LobbyPoint>>) -> Vec<Vec<Vec<(usize,usize)>>> {
    grid.into_iter().enumerate().map(|(y,row)|
        row.into_iter().enumerate().map(move |(x,lp)|
            match lp {
                LobbyPoint::Floor => vec![],
                _ => neighbours(x,y).flat_map(|(xn,yn)|
                    usize::try_from(yn).ok().and_then(|yn|
                        grid.get(yn).and_then(|row|
                            usize::try_from(xn).ok().and_then(|xn|
                                row.get(xn).and_then(|lp|
                                    match lp {
                                        LobbyPoint::Floor => None,
                                        _ => Some((xn,yn)),
                                    }
                                )
                            )
                        )
                    ).into_iter()
                ).collect(),
            }
        ).collect()
    ).collect()

[9.541]

[6.966]

fn build_neighbourhoods_v1(grid: &Vec<Vec<LobbyPoint>>) -> Vec<Vec<Vec<(usize, usize)>>> {
    grid.into_iter()
        .enumerate()
        .map(|(y, row)| {
            row.into_iter()
                .enumerate()
                .map(move |(x, lp)| match lp {
                    LobbyPoint::Floor => vec![],
                    _ => neighbours(x, y)
                        .flat_map(|(xn, yn)| {
                            usize::try_from(yn)
                                .ok()
                                .and_then(|yn| {
                                    grid.get(yn).and_then(|row| {
                                        usize::try_from(xn).ok().and_then(|xn| {
                                            row.get(xn).and_then(|lp| match lp {
                                                LobbyPoint::Floor => None,
                                                _ => Some((xn, yn)),
                                            })
                                        })
                                    })
                                })
                                .into_iter()
                        })
                        .collect(),
                })
                .collect()
        })
        .collect()

Replacement in 2020/day11.rs at line 59 [9.11]

B:BD[6.969] → [6.969:1082]

fn seek_line(x0: usize, y0: usize, xd: isize, yd: isize, grid: &Vec<Vec<LobbyPoint>>) -> Option<(usize,usize)> {

[6.969]

[6.1082]

fn seek_line(
    x0: usize,
    y0: usize,
    xd: isize,
    yd: isize,
    grid: &Vec<Vec<LobbyPoint>>,
) -> Option<(usize, usize)> {

Replacement in 2020/day11.rs at line 68 [9.11]

B:BD[6.1166] → [6.1166:1326]

    grid.get(y).and_then(|row| row.get(x)).and_then(|lp| match lp {
        LobbyPoint::Floor => seek_line(x, y, xd, yd, grid),
        _ => Some((x,y))
    })

[6.1166]

[6.1326]

    grid.get(y)
        .and_then(|row| row.get(x))
        .and_then(|lp| match lp {
            LobbyPoint::Floor => seek_line(x, y, xd, yd, grid),
            _ => Some((x, y)),
        })

Replacement in 2020/day11.rs at line 76 [9.11]

B:BD[6.1329] → [6.1329:1614]

fn neighbours_v2<'a>(xc: usize, yc: usize, grid: &'a Vec<Vec<LobbyPoint>>) -> impl Iterator<Item=(usize,usize)> + 'a {
    (-1 .. 2).flat_map(move |y| (-1 .. 2).map(move |x| (x,y)))
        .filter(|p| *p != (0,0))
        .flat_map(move |(x,y)| seek_line(xc,yc,x,y,grid).into_iter())

[6.1329]

[6.1614]

fn neighbours_v2<'a>(
    xc: usize,
    yc: usize,
    grid: &'a Vec<Vec<LobbyPoint>>,
) -> impl Iterator<Item = (usize, usize)> + 'a {
    (-1..2)
        .flat_map(move |y| (-1..2).map(move |x| (x, y)))
        .filter(|p| *p != (0, 0))
        .flat_map(move |(x, y)| seek_line(xc, yc, x, y, grid).into_iter())

Replacement in 2020/day11.rs at line 87 [9.11]

B:BD[6.1617] → [6.1617:1707]

∅:D[6.1707] → [9.609:656]

B:BD[9.609] → [9.609:656]

B:BD[9.656] → [6.1708:1936]

fn build_neighbourhoods_v2(grid: &Vec<Vec<LobbyPoint>>) -> Vec<Vec<Vec<(usize,usize)>>> {
    grid.into_iter().enumerate().map(|(y,row)|
        row.into_iter().enumerate().map(move |(x,lp)|
            match lp {
                LobbyPoint::Floor => vec![],
                _ => neighbours_v2(x,y,grid).collect(),
            }
        ).collect()
    ).collect()

[6.1617]

[6.1936]

fn build_neighbourhoods_v2(grid: &Vec<Vec<LobbyPoint>>) -> Vec<Vec<Vec<(usize, usize)>>> {
    grid.into_iter()
        .enumerate()
        .map(|(y, row)| {
            row.into_iter()
                .enumerate()
                .map(move |(x, lp)| match lp {
                    LobbyPoint::Floor => vec![],
                    _ => neighbours_v2(x, y, grid).collect(),
                })
                .collect()
        })
        .collect()

Replacement in 2020/day11.rs at line 102 [9.11]

B:BD[6.1939] → [6.1939:2204]

∅:D[6.2204] → [9.716:787]

B:BD[9.716] → [9.716:787]

B:BD[9.787] → [6.2205:2378]

∅:D[6.2378] → [9.1369:1396]

B:BD[9.1369] → [9.1369:1396]

B:BD[9.1396] → [6.2379:2762]

∅:D[6.2762] → [9.1597:1659]

B:BD[9.1597] → [9.1597:1659]

B:BD[9.1659] → [6.2763:2778]

∅:D[6.2778] → [9.1673:1710]

B:BD[9.1673] → [9.1673:1710]

fn time_step(grid: &Vec<Vec<LobbyPoint>>, neighbourhoods: &Vec<Vec<Vec<(usize,usize)>>>, threshold: u16) -> Vec<Vec<LobbyPoint>> {
    grid.into_iter().zip(neighbourhoods.into_iter()).map(|(gr,nr)|
        gr.into_iter().zip(nr.into_iter()).map(|(lp,n)| match lp {
            LobbyPoint::Floor => LobbyPoint::Floor,
            _ => {
                let c: u16 = n.into_iter().map(|(x,y)| match grid[*y][*x] {
                    LobbyPoint::Full => 1,
                    _ => 0,
                }).sum();
                match lp {
                    LobbyPoint::Full => if c >= threshold {
                        LobbyPoint::Empty
                    } else {
                        LobbyPoint::Full
                    },
                    LobbyPoint::Empty => if c == 0 {
                        LobbyPoint::Full
                    } else {
                        LobbyPoint::Empty
                    },
                    _ => LobbyPoint::Floor,
                }
            },
        }).collect()
    ).collect()

[6.1939]

[9.1710]

fn time_step(
    grid: &Vec<Vec<LobbyPoint>>,
    neighbourhoods: &Vec<Vec<Vec<(usize, usize)>>>,
    threshold: u16,
) -> Vec<Vec<LobbyPoint>> {
    grid.into_iter()
        .zip(neighbourhoods.into_iter())
        .map(|(gr, nr)| {
            gr.into_iter()
                .zip(nr.into_iter())
                .map(|(lp, n)| match lp {
                    LobbyPoint::Floor => LobbyPoint::Floor,
                    _ => {
                        let c: u16 = n
                            .into_iter()
                            .map(|(x, y)| match grid[*y][*x] {
                                LobbyPoint::Full => 1,
                                _ => 0,
                            })
                            .sum();
                        match lp {
                            LobbyPoint::Full => {
                                if c >= threshold {
                                    LobbyPoint::Empty
                                } else {
                                    LobbyPoint::Full
                                }
                            }
                            LobbyPoint::Empty => {
                                if c == 0 {
                                    LobbyPoint::Full
                                } else {
                                    LobbyPoint::Empty
                                }
                            }
                            _ => LobbyPoint::Floor,
                        }
                    }
                })
                .collect()
        })
        .collect()

Replacement in 2020/day11.rs at line 147 [9.11]

B:BD[9.1764] → [9.1764:1846]

    src.lines().map(|l| l.chars().map(LobbyPoint::from_char).collect()).collect()

[9.1764]

[9.1846]

    src.lines()
        .map(|l| l.chars().map(LobbyPoint::from_char).collect())
        .collect()

Replacement in 2020/day11.rs at line 156 [9.11]

B:BD[6.2842] → [6.2842:3000]

        "1" => (build_neighbourhoods_v1(&grid),4),
        "2" => (build_neighbourhoods_v2(&grid),5),
        _ => panic!("Version number (1 or 2) expected")

[6.2842]

[6.3000]

        "1" => (build_neighbourhoods_v1(&grid), 4),
        "2" => (build_neighbourhoods_v2(&grid), 5),
        _ => panic!("Version number (1 or 2) expected"),

Replacement in 2020/day11.rs at line 167 [9.11]

B:BD[9.2139] → [9.2139:2304]

    };
    println!("{}", grid.into_iter().flat_map(|row| row.into_iter().map(|pt| match pt {
        LobbyPoint::Full => 1,
        _ => 0,
    })).sum::<usize>())

[9.2139]

[9.2304]

    }
    println!(
        "{}",
        grid.into_iter()
            .flat_map(|row| row.into_iter().map(|pt| match pt {
                LobbyPoint::Full => 1,
                _ => 0,
            }))
            .sum::<usize>()
    )

Deletion in 2020/day11.rs at line 178 [9.11]
B:BD[9.2306] → [9.2306:2307]
Replacement in 2020/day1.rs at line 10 [10.28]
B:BD[10.148] → [10.148:174]
```
    type Item=Vec<usize>;
```
[10.148]
[10.174]
```
    type Item = Vec<usize>;
```

Replacement in 2020/day1.rs at line 22 [10.28]

B:BD[10.514] → [10.514:567]

                for ixiy in ixix .. self.ixs.len() {

[10.514]

[10.567]

                for ixiy in ixix..self.ixs.len() {

Replacement in 2020/day1.rs at line 24 [10.28]

B:BD[10.607] → [10.607:672]

                };
                return Some(self.ixs.clone())

[10.607]

[10.672]

                }
                return Some(self.ixs.clone());

Replacement in 2020/day1.rs at line 33 [10.28]

B:BD[10.763] → [10.763:819]

        let mut r = Ixs { ixs: Vec::new(), max: max, };

[10.763]

[10.819]

        let mut r = Ixs {
            ixs: Vec::new(),
            max: max,
        };

Replacement in 2020/day1.rs at line 44 [10.28]

B:BD[10.975] → [10.975:1097]

        if ixs.iter().map(|ix| i[*ix] ).sum::<i64>() == 2020 {
            return ixs.iter().map(|ix| i[*ix] ).product();

[10.975]

[10.1097]

        if ixs.iter().map(|ix| i[*ix]).sum::<i64>() == 2020 {
            return ixs.iter().map(|ix| i[*ix]).product();

cargo fmt

Dependencies

In channels

Change contents

Deletion in 2020/day7.rs at line 1 [5.1481]

Insertion in 2020/day7.rs at line 2 [5.1481]

Replacement in 2020/day7.rs at line 6 [5.1481]

Replacement in 2020/day7.rs at line 9 [5.1481]

Replacement in 2020/day7.rs at line 34 [5.1481]

Replacement in 2020/day7.rs at line 45 [5.1481]

Replacement in 2020/day7.rs at line 67 [5.1481]

Replacement in 2020/day7.rs at line 74 [5.1481]

Replacement in 2020/day7.rs at line 97 [5.1481]

Replacement in 2020/day7.rs at line 105 [5.1481]

Replacement in 2020/day7.rs at line 117 [5.1481]

Replacement in 2020/day7.rs at line 132 [5.1481]

Replacement in 2020/day7.rs at line 152 [5.1481]

Replacement in 2020/day7.rs at line 154 [5.1481]

Replacement in 2020/day7.rs at line 163 [5.1481]

Replacement in 2020/day7.rs at line 174 [5.1481]

Replacement in 2020/day7.rs at line 191 [5.1481]

Replacement in 2020/day7.rs at line 197 [5.1481]

Replacement in 2020/day7.rs at line 200 [5.1481]

Replacement in 2020/day7.rs at line 217 [5.1481]

Deletion in 2020/day7.rs at line 226 [5.1481]

Replacement in 2020/day6.rs at line 13 [4.10]

Replacement in 2020/day6.rs at line 25 [4.10]

Replacement in 2020/day6.rs at line 28 [4.10]

Replacement in 2020/day6.rs at line 48 [4.10]

Replacement in 2020/day6.rs at line 54 [4.10]

Replacement in 2020/day6.rs at line 63 [4.10]

Deletion in 2020/day6.rs at line 76 [4.10]

Replacement in 2020/day5.rs at line 3 [5.10]

Replacement in 2020/day5.rs at line 8 [5.10]

Replacement in 2020/day5.rs at line 23 [5.10]

Replacement in 2020/day5.rs at line 30 [5.10]

Replacement in 2020/day5.rs at line 34 [5.10]

Replacement in 2020/day5.rs at line 39 [5.10]

Replacement in 2020/day5.rs at line 54 [5.10]

Replacement in 2020/day5.rs at line 57 [5.10]

Replacement in 2020/day4.rs at line 4 [3.10]

Replacement in 2020/day4.rs at line 9 [3.10]

Replacement in 2020/day4.rs at line 13 [3.10]

Replacement in 2020/day4.rs at line 24 [3.10]

Replacement in 2020/day4.rs at line 32 [3.10]

Replacement in 2020/day4.rs at line 40 [3.10]

Replacement in 2020/day4.rs at line 60 [3.10]

Replacement in 2020/day4.rs at line 63 [3.10]

Replacement in 2020/day4.rs at line 85 [3.10]

Replacement in 2020/day4.rs at line 97 [3.10]

Replacement in 2020/day4.rs at line 99 [3.10]

Replacement in 2020/day4.rs at line 105 [3.10]

Replacement in 2020/day4.rs at line 114 [3.10]

Replacement in 2020/day4.rs at line 129 [3.10]

Replacement in 2020/day4.rs at line 134 [3.10]

Replacement in 2020/day4.rs at line 138 [3.10]

Replacement in 2020/day4.rs at line 144 [3.10]

Replacement in 2020/day4.rs at line 147 [3.10]

Replacement in 2020/day4.rs at line 154 [3.10]

Replacement in 2020/day4.rs at line 156 [3.10]

Replacement in 2020/day4.rs at line 172 [3.10]

Deletion in 2020/day4.rs at line 182 [3.10]

Replacement in 2020/day3.rs at line 4 [2.10]

Replacement in 2020/day3.rs at line 16 [2.10]

Replacement in 2020/day3.rs at line 21 [2.10]

Replacement in 2020/day3.rs at line 28 [2.10]

Replacement in 2020/day3.rs at line 36 [2.10]

Replacement in 2020/day3.rs at line 45 [2.10]

Replacement in 2020/day3.rs at line 60 [2.10]

Replacement in 2020/day3.rs at line 62 [2.10]

Replacement in 2020/day3.rs at line 65 [2.10]

Replacement in 2020/day15.rs at line 31 [8.11]

Deletion in 2020/day15.rs at line 41 [8.11]

Insertion in 2020/day15.rs at line 42 [8.11]

Replacement in 2020/day15.rs at line 50 [8.11]

Replacement in 2020/day15.rs at line 58 [8.11]

Replacement in 2020/day12.rs at line 3 [7.11]

Replacement in 2020/day12.rs at line 8 [7.11]

Replacement in 2020/day12.rs at line 11 [7.11]

Replacement in 2020/day12.rs at line 13 [7.11]