Robotti

warning: unused import: `std::cmp::Ordering`
 --> input/code.rs:1:5
  |
1 | use std::cmp::Ordering;
  |     ^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

warning: function `dist` is never used
   --> input/code.rs:111:4
    |
111 | fn dist((a, b): (usize, usize)) -> usize {
    |    ^^^^
    |
    = note: `#[warn(dead_code)]` on by default

warning: 2 warnings emitted

use std::cmp::Ordering;

use rand::prelude::*;

fn main() {
    let debug_mode = std::env::args().any(|x| x == "debug".to_string());
    let auto = std::env::args().any(|x| x == "auto".to_string());

    let mut n: String = "".into();
    std::io::stdin().read_line(&mut n).expect("IO Ongelma :(");
    let n: usize = n.trim().parse().expect("Eka rivi ei ollut numero");

    let mut line: String = "".into();

    if !auto {
        // **..**..R..** juttu
        std::io::stdin()
            .read_line(&mut line)
            .expect("IO Ongelma :(");
    } else {
        let mut rng = rand::thread_rng();
        for _ in 0..n {
            let num = rng.gen_range(0.0..=1.);
            if num < 0.3 {
                line.push('*');
            } else {
                line.push('.');
            }
        }

        let half = n / 2;
        line.replace_range(half..=half, "R");
    }

    let mut askeleet = 0;
    let mut kolikot = 0;

    let mut robotti_pos = pos_of_c(&line, 'R')
        .first()
        .expect("Ei R:ää (robottia)")
        .clone();
    let mut kolikko_positions = pos_of_c(&line, '*').clone();

    let time = get_timer();
    while let Some(close) = closest(robotti_pos, &kolikko_positions) {
        // Optimisaatio
        let diff = close as i32 - robotti_pos as i32;

        askeleet += diff.abs();
        robotti_pos = (robotti_pos as i32 + diff) as usize;

        kolikot += 1;

        kolikko_positions.retain(|x| *x != close);

        //DEBUG
        /*if debug_mode {
            for i in 0..n {
                if i == robotti_pos {
                    print!("R");
                } else if kolikko_positions.contains(&i) {
                    print!("*");
                } else {
                    print!(".");
                }
            }
            println!("");
        }*/
    }

    println!("{} {}", askeleet, kolikot);
    if debug_mode {
        println!("Kesti {}", get_timer() - time);
    }
}

// Pakko alkaa mittaamaan ku ei kelvannu mun 0.2 sekuntia
// Kestävä ratkasu
fn get_timer() -> f64 {
    std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .expect("Time went backwards")
        .as_secs_f64()
}

#[inline(always)]
fn closest(pos: usize, coins: &[usize]) -> Option<usize> {
    coins
        .binary_search_by(|&coin_pos| coin_pos.cmp(&pos))
        .map_or_else(
            |idx| {
                // Find the nearest left or right position
                let left = idx.checked_sub(1).and_then(|i| coins.get(i));
                let right = coins.get(idx);
                match (left, right) {
                    (Some(&l), Some(&r)) => Some(if pos.abs_diff(l) <= pos.abs_diff(r) {
                        l
                    } else {
                        r
                    }),
                    (Some(&l), None) => Some(l),
                    (None, Some(&r)) => Some(r),
                    _ => None,
                }
            },
            |idx| Some(coins[idx]),
        )
}

#[inline(always)]
fn dist((a, b): (usize, usize)) -> usize {
    a.abs_diff(b)
}

fn pos_of_c(s: &str, c: char) -> Vec<usize> {
    // *
    let mut pos = vec![];

    for (i, char) in s.chars().enumerate() {
        if char == c {
            pos.push(i);
        }
    }

    pos
}

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: WRONG ANSWER

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: WRONG ANSWER

Test 9

Group: 1, 2

Verdict: WRONG ANSWER

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

Test 20

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 21

Group: 2

Verdict: ACCEPTED

Test 22

Group: 2

Verdict: ACCEPTED

Test 23

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 24

Group: 2

Verdict: TIME LIMIT EXCEEDED