Robotti

use std::io::stdin;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum RoomType {
    Robot,
    Coin,
    Empty,
}

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

impl Direction {
    fn get_inner(&self) -> i32 {
        match self {
            Direction::Left(x) => *x,
            Direction::Right(x) => *x,
            Direction::Same => 0,
        }
    }
}

impl RoomType {
    fn from_char(c: char) -> Self {
        use RoomType::*;
        match c {
            'R' => Robot,
            '*' => Coin,
            '.' => Empty,
            _ => panic!("Should Be One Of The Above"),
        }
    }
}

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 mut arr: Vec<RoomType> = line
        .strip_suffix('\n')
        .unwrap()
        .chars()
        .map(|c| RoomType::from_char(c))
        .collect();

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

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

    let mut next_coin = find_next_coin(startpos, &arr);

    dbg!(next_coin);

    while next_coin != Direction::Same {
        coin_count += 1;
        steps += next_coin.get_inner();

        match next_coin {
            Direction::Left(x) => startpos -= x as usize,
            Direction::Right(x) => startpos += x as usize,
            Direction::Same => unreachable!(),
        };

        arr[startpos] = RoomType::Empty;

        next_coin = find_next_coin(startpos, &arr)
    }

    println!("{} {}", steps, coin_count);
}

fn find_next_coin(startpos: usize, arr: &Vec<RoomType>) -> Direction {
    let mut rp = startpos.checked_add(1);
    let mut lp = startpos.checked_sub(1);

    let mut distance_to_left_room = 1;
    let mut distance_to_right_room = 1;

    let mut didnt_hit_left_wall = false;
    let mut didnt_hit_right_wall = false;

    while let Some(room) = get_room(rp, &arr) {
        match room {
            RoomType::Robot => (),
            RoomType::Coin => {
                didnt_hit_right_wall = true;
                break;
            }
            RoomType::Empty => (),
        }

        distance_to_right_room += 1;
        rp = match rp {
            Some(x) => x.checked_add(1),
            None => None,
        };
    }

    while let Some(room) = get_room(lp, &arr) {
        match room {
            RoomType::Robot => (),
            RoomType::Coin => {
                didnt_hit_left_wall = true;
                break;
            }
            RoomType::Empty => (),
        }

        distance_to_left_room += 1;
        lp = match lp {
            Some(x) => x.checked_sub(1),
            None => None,
        };
    }

    if !didnt_hit_left_wall && !didnt_hit_right_wall {
        return Direction::Same;
    }

    if !didnt_hit_left_wall {
        return Direction::Right(distance_to_right_room);
    }

    if !didnt_hit_right_wall {
        return Direction::Left(distance_to_left_room);
    }

    match distance_to_left_room.cmp(&distance_to_right_room) {
        std::cmp::Ordering::Less => Direction::Left(distance_to_left_room),
        std::cmp::Ordering::Equal => Direction::Same,
        std::cmp::Ordering::Greater => Direction::Right(distance_to_right_room),
    }
}

fn get_room(pos: Option<usize>, arr: &Vec<RoomType>) -> Option<RoomType> {
    match pos {
        Some(p) => arr.get(p).or(None).copied(),
        None => None,
    }
}

Test 1

Group: 1, 2

Verdict: ACCEPTED

[input/code.rs:66] next_coin = Same

Test 2

Group: 1, 2

Verdict: ACCEPTED

[input/code.rs:66] next_coin = Same

Test 3

Group: 1, 2

Verdict: ACCEPTED

[input/code.rs:66] next_coin = Left(
    2,
)

Test 4

Group: 1, 2

Verdict: ACCEPTED

[input/code.rs:66] next_coin = Same

Test 5

Group: 1, 2

Verdict: ACCEPTED

[input/code.rs:66] next_coin = Right(
    148,
)

Test 6

Group: 1, 2

Verdict: ACCEPTED

[input/code.rs:66] next_coin = Left(
    159,
)

Test 7

Group: 1, 2

Verdict: ACCEPTED

[input/code.rs:66] next_coin = Left(
    2,
)

Test 8

Group: 1, 2

Verdict: ACCEPTED

[input/code.rs:66] next_coin = Same

Test 9

Group: 1, 2

Verdict: ACCEPTED

[input/code.rs:66] next_coin = Same

Test 10

Group: 1, 2

Verdict: ACCEPTED

[input/code.rs:66] next_coin = Right(
    1,
)

Test 11

Group: 1, 2

Verdict: ACCEPTED

[input/code.rs:66] next_coin = Left(
    1,
)

Test 12

Group: 2

Verdict: ACCEPTED

[input/code.rs:66] next_coin = Right(
    3,
)

Test 13

Group: 2

Verdict: ACCEPTED

[input/code.rs:66] next_coin = Left(
    5,
)

Test 14

Group: 2

Verdict: ACCEPTED

[input/code.rs:66] next_coin = Left(
    1,
)

Test 15

Group: 2

Verdict: ACCEPTED

[input/code.rs:66] next_coin = Right(
    1,
)

Test 16

Group: 2

Verdict: ACCEPTED

[input/code.rs:66] next_coin = Left(
    1,
)

Test 17

Group: 2

Verdict: ACCEPTED

[input/code.rs:66] next_coin = Same

Test 18

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 19

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 20

Group: 2

Verdict: ACCEPTED

[input/code.rs:66] next_coin = Same

Test 21

Group: 2

Verdict: ACCEPTED

[input/code.rs:66] next_coin = Right(
    70142,
)

Test 22

Group: 2

Verdict: ACCEPTED

[input/code.rs:66] next_coin = Right(
    66,
)

Test 23

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 24

Group: 2

Verdict: TIME LIMIT EXCEEDED