Robotti

#[cfg(test)]
mod tests;

use std::{io::stdin, ops::Add};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum RoomType {
    Robot,
    Coin,
    Empty,
}

#[derive(Debug, Clone, Copy)]
enum Ordering {
    Less,
    Greater,
    Equal,
    BothInvalid,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
enum Direction {
    Left,
    Right,
}

struct Pointer {
    pos: usize,
    max_len: usize,
    direction: Direction,
}

impl Pointer {
    ///True Means Incremented
    fn try_increment(&mut self) -> bool {
        let num = match self.direction {
            Direction::Left => self.pos.checked_sub(1),
            Direction::Right => {
                if self.pos + 1 <= self.max_len {
                    Some(self.pos.add(1))
                } else {
                    None
                }
            }
        };

        match num {
            Some(x) => {
                self.pos = x;
                true
            }
            None => false,
        }
    }

    fn cmp_with_start(&self, other: &Self, start_pos: usize) -> Ordering {
        let dist_to_self = self.dist_from_start(start_pos);
        let dist_to_other = other.dist_from_start(start_pos);

        match (self.is_edged(), other.is_edged()) {
            (true, true) => Ordering::BothInvalid,
            (true, false) => Ordering::Greater,
            (false, true) => Ordering::Less,
            (false, false) => match dist_to_self.cmp(&dist_to_other) {
                std::cmp::Ordering::Less => Ordering::Less,
                std::cmp::Ordering::Equal => Ordering::Equal,
                std::cmp::Ordering::Greater => Ordering::Greater,
            },
        }
        //Add comparison which fails or sum when is edged
    }

    fn dist_from_start(&self, start_pos: usize) -> usize {
        match self.direction {
            Direction::Left => start_pos - self.pos,
            Direction::Right => self.pos - start_pos,
        }
    }

    fn is_edged(&self) -> bool {
        match self.direction {
            Direction::Left => self.pos <= 0,
            Direction::Right => self.pos >= self.max_len,
        }
    }
}

impl From<char> for RoomType {
    fn from(value: char) -> Self {
        match value {
            'R' => RoomType::Robot,
            '*' => RoomType::Coin,
            '.' => RoomType::Empty,
            _ => panic!(),
        }
    }
}

fn main() {
    let mut line = String::new();

    stdin().read_line(&mut line).unwrap();
    let len: usize = line.strip_suffix('\n').unwrap_or(&line).parse().unwrap();

    line = "".to_string();

    stdin().read_line(&mut line).unwrap();

    let (steps, coins) = do_challenge(line, len);

    println!("{} {}", steps, coins)
}

fn do_challenge(line: String, len: usize) -> (usize, i32) {
    let mut arr: Vec<RoomType> = line
        .strip_suffix('\n')
        .unwrap()
        .chars()
        .map(|c| c.into())
        .collect();

    let mut robot_pos = arr
        .iter()
        .position(|x| *x == RoomType::Robot)
        .expect("No robot");

    let mut coin_count = 0;
    let mut steps = 0;

    let mut lp = Pointer {
        pos: robot_pos,
        max_len: len - 1,
        direction: Direction::Left,
    };
    let mut rp = Pointer {
        direction: Direction::Right,
        ..lp
    };

    loop {
        match lp.cmp_with_start(&rp, robot_pos) {
            Ordering::Less => {
                lp.try_increment();
            }
            Ordering::Greater => {
                rp.try_increment();
            }
            Ordering::Equal => {
                lp.try_increment();
                rp.try_increment();
            }
            Ordering::BothInvalid => break,
        }

        match (arr[lp.pos] == RoomType::Coin, arr[rp.pos] == RoomType::Coin) {
            (true, true) => break,
            (true, false) => {
                steps += lp.dist_from_start(robot_pos);
                robot_pos = lp.pos;
                coin_count += 1;
                arr[lp.pos] = RoomType::Empty;
            }
            (false, true) => {
                steps += rp.dist_from_start(robot_pos);
                robot_pos = rp.pos;
                coin_count += 1;
                arr[rp.pos] = RoomType::Empty;
            }
            (false, false) => continue,
        }
    }

    (steps, coin_count)
}

Test 1

Group: 1, 2

Verdict: ACCEPTED

Test 2

Group: 1, 2

Verdict: ACCEPTED

Test 3

Group: 1, 2

Verdict: ACCEPTED

Test 4

Group: 1, 2

Verdict: ACCEPTED

Test 5

Group: 1, 2

Verdict: ACCEPTED

Test 6

Group: 1, 2

Verdict: ACCEPTED

Test 7

Group: 1, 2

Verdict: ACCEPTED

Test 8

Group: 1, 2

Verdict: ACCEPTED

Test 9

Group: 1, 2

Verdict: ACCEPTED

Test 10

Group: 1, 2

Verdict: ACCEPTED

Test 11

Group: 1, 2

Verdict: ACCEPTED

Test 12

Group: 2

Verdict: ACCEPTED

Test 13

Group: 2

Verdict: ACCEPTED

Test 14

Group: 2

Verdict: ACCEPTED

Test 15

Group: 2

Verdict: ACCEPTED

Test 16

Group: 2

Verdict: ACCEPTED

Test 17

Group: 2

Verdict: ACCEPTED

Test 18

Group: 2

Verdict: ACCEPTED

Test 19

Group: 2

Verdict: ACCEPTED

Test 20

Group: 2

Verdict: ACCEPTED

Test 21

Group: 2

Verdict: ACCEPTED

Test 22

Group: 2

Verdict: ACCEPTED

Test 23

Group: 2

Verdict: ACCEPTED

Test 24

Group: 2

Verdict: ACCEPTED