Robotti

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

warning: function `dist` is never used
   --> input/code.rs:125:4
    |
125 | fn dist((a, b): (usize, usize)) -> usize {
    |    ^^^^

warning: 2 warnings emitted

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() as i32;
 
    let mut kolikko_diffs: Vec<i32> = pos_of_c(&line, '*')
        .iter()
        .map(|x| *x as i32 - robotti_pos as i32)
        .collect();
    kolikko_diffs.sort_by(|x, y| x.abs().cmp(&y.abs()));
 
    loop {
        if kolikko_diffs.get(0).map(|x| x.abs()) == kolikko_diffs.get(1).map(|x| x.abs()) {
            break;
        }
 
        let diff = kolikko_diffs.get(0).map(|x| *x);
 
        // Unwrap
        let diff = match diff {
            None => break,
            Some(s) => s,
        };
 
        askeleet += diff.abs();
        robotti_pos = robotti_pos + diff;
 
        for d in kolikko_diffs.iter_mut() {
            *d -= diff;
        }
 
        kolikot += 1;
        kolikko_diffs.remove(0);
 
        //DEBUG
        if debug_mode {
            for i in 0..n {
                if i == robotti_pos as usize {
                    print!("R");
                } else if pos_of_c(&line, '*').contains(&i) {
                    print!("*");
                } else {
                    print!(".");
                }
            }
            println!("");
        }
    }
 
    println!("{} {}", askeleet, kolikot);
}
 
#[inline(always)]
fn closest(a: &usize, b: &[usize]) -> Option<usize> {
    let mut c = usize::MAX;
    let mut c_index = 0;
 
    if b.is_empty() {
        return None;
    }
 
    // let distances = b.iter().map(|x| dist((*a, *x)));
 
    for i in 0..b.len() {
        let diff = dist((*a, b[i]));
        if diff < c {
            c = diff;
            c_index = i;
        }
    }
 
    // Toinen looppi joka tarkistaa jos on toinen yhtä kaukana oleva
    for i in 0..b.len() {
        if i == c_index {
            continue;
        }
 
        let diff = dist((*a, b[i]));
 
        // Tyhmä ropotti >:(
        if diff == c {
            return None;
        }
    }
 
    Some(b[c_index])
}
 
#[inline(always)]
fn dist((a, b): (usize, usize)) -> usize {
    a.abs_diff(b)
}
 
fn pos_of_c(s: &String, 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: ACCEPTED

Test 5

Group: 1, 2

Verdict: ACCEPTED

Test 6

Group: 1, 2

Verdict: ACCEPTED

Test 7

Group: 1, 2

Verdict: WRONG ANSWER

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

Test 13

Group: 2

Verdict: ACCEPTED

Test 14

Group: 2

Verdict: WRONG ANSWER

Test 15

Group: 2

Verdict: ACCEPTED

Test 16

Group: 2

Verdict: ACCEPTED

Test 17

Group: 2

Verdict: ACCEPTED

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: ACCEPTED

Test 22

Group: 2

Verdict: ACCEPTED

Test 23

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 24

Group: 2

Verdict: TIME LIMIT EXCEEDED