Robotti

warning: unused import: `time::Instant`
 --> input/code.rs:1:22
  |
1 | use std::{io::stdin, time::Instant};
  |                      ^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

warning: variable does not need to be mutable
  --> input/code.rs:48:9
   |
48 |     let mut arr: Vec<RoomType> = line
   |         ----^^^
   |         |
   |         help: remove this `mut`
   |
   = note: `#[warn(unused_mut)]` on by default

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 {
   | -...

use std::{io::stdin, time::Instant};

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

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

        if left_distance < right_distance {
            lp = lp.saturating_sub(1);
            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 rp < len - 1 {
                        rp += 1
                    };
                    lp = lp.saturating_sub(1);
                }
            }
        } else {
            if rp < len - 1 {
                rp += 1;
            }

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

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

Test 1

Group: 1, 2

Verdict: TIME LIMIT EXCEEDED

Test 2

Group: 1, 2

Verdict: TIME LIMIT EXCEEDED

Test 3

Group: 1, 2

Verdict: TIME LIMIT EXCEEDED

Test 4

Group: 1, 2

Verdict: ACCEPTED

Test 5

Group: 1, 2

Verdict: TIME LIMIT EXCEEDED

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: TIME LIMIT EXCEEDED

Test 11

Group: 1, 2

Verdict: TIME LIMIT EXCEEDED

Test 12

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 13

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 14

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 15

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 16

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 17

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 18

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 19

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 20

Group: 2

Verdict: ACCEPTED

Test 21

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 22

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 23

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 24

Group: 2

Verdict: TIME LIMIT EXCEEDED