Robotti

warning: variants `Left`, `Right`, and `Same` are never constructed
  --> input/code.rs:12:5
   |
11 | enum Direction {
   |      --------- variants in this enum
12 |     Left(i32),
   |     ^^^^
13 |     Right(i32),
   |     ^^^^^
14 |     Same,
   |     ^^^^
   |
   = note: `Direction` has derived impls for the traits `Clone` and `Debug`, but these are intentionally ignored during dead code analysis
   = note: `#[warn(dead_code)]` on by default

warning: method `get_inner` is never used
  --> input/code.rs:18:8
   |
17 | impl Direction {
   | -------------- method in this implementation
18 |     fn get_inner(&self) -> i32 {
   |        ^^^^^^^^^

warning: 2 warnings emitted

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 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 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 = robot_pos;
    let mut rp = robot_pos;

    let mut right_wall_hit = false;
    let mut left_wall_hit = false;

    loop {
        let left_distance = robot_pos - lp;
        let right_distance = rp - robot_pos;

        if left_wall_hit && right_wall_hit {
            break;
        }

        if left_distance < right_distance && !left_wall_hit {
            lp = match lp.checked_sub(1) {
                Some(x) => x,
                None => {
                    left_wall_hit = true;
                    0
                }
            };
            match arr[lp] {
                RoomType::Coin => {
                    robot_pos = lp;
                    coin_count += 1;
                    steps += left_distance;
                }
                _ => (),
            }
        } else if left_distance == right_distance {
            match (arr[lp] == RoomType::Coin, arr[rp] == RoomType::Coin) {
                (true, true) => break,
                (true, false) => {
                    robot_pos = lp;
                    coin_count += 1;
                    steps += left_distance;
                }
                (false, true) => {
                    robot_pos = rp;
                    coin_count += 1;
                    steps += left_distance;
                }
                (false, false) => {
                    if lp == 0 && rp == len - 1 {
                        break;
                    }

                    if rp < len - 1 {
                        rp += 1
                    };
                    lp = lp.saturating_sub(1);
                }
            }
        } else {
            if rp < len - 1 {
                rp += 1;
            } else {
                right_wall_hit = true;
            }

            match arr[rp] {
                RoomType::Coin => {
                    robot_pos = rp;
                    coin_count += 1;
                    steps += right_distance;
                }
                _ => (),
            }
        }
    }

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

Test 1

Group: 1, 2

Verdict: ACCEPTED

Test 2

Group: 1, 2

Verdict: ACCEPTED

Test 3

Group: 1, 2

Verdict: WRONG ANSWER

Test 4

Group: 1, 2

Verdict: ACCEPTED

Test 5

Group: 1, 2

Verdict: WRONG ANSWER

Test 6

Group: 1, 2

Verdict: TIME LIMIT EXCEEDED

Test 7

Group: 1, 2

Verdict: TIME LIMIT EXCEEDED

Test 8

Group: 1, 2

Verdict: ACCEPTED

Test 9

Group: 1, 2

Verdict: ACCEPTED

Test 10

Group: 1, 2

Verdict: WRONG ANSWER

Test 11

Group: 1, 2

Verdict: TIME LIMIT EXCEEDED

Test 12

Group: 2

Verdict: WRONG ANSWER

Test 13

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 14

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 15

Group: 2

Verdict: WRONG ANSWER

Test 16

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 17

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 18

Group: 2

Verdict: WRONG ANSWER

Test 19

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 20

Group: 2

Verdict: ACCEPTED

Test 21

Group: 2

Verdict: WRONG ANSWER

Test 22

Group: 2

Verdict: WRONG ANSWER

Test 23

Group: 2

Verdict: WRONG ANSWER

Test 24

Group: 2

Verdict: TIME LIMIT EXCEEDED