Monistus

warning: variable does not need to be mutable
  --> input/code.rs:14:9
   |
14 |     let mut i: usize = 0;
   |         ----^
   |         |
   |         help: remove this `mut`
   |
   = note: `#[warn(unused_mut)]` on by default

warning: function `collect` is never used
  --> input/code.rs:42:4
   |
42 | fn collect(queue: &VecDeque<char>, start: usize, len: usize) -> VecDeque<char> {
   |    ^^^^^^^
   |
   = note: `#[warn(dead_code)]` on by default

warning: 2 warnings emitted

use std::collections::VecDeque;
 
fn main() {
    let mut input: String = String::new();
    std::io::stdin().read_line(&mut input).unwrap();
    input = input.strip_suffix("\n").unwrap().to_string();
 
 
    println!("{}", process(input.chars().collect()))
}
 
fn process(mut input: VecDeque<char>) -> String {
    let mut output = String::new();
    let mut i: usize = 0;
    while i < input.len() {
        let character = input[i];
 
        match character.to_digit(10) {
            None => {
                output.push(character);
                input.pop_front();
            }
            Some(len) => {
                input.pop_front(); // Remove digit
                let capture = input.drain(i .. i + len as usize).collect(); // Remove duplicated area
 
                let mut duplicate = duplicate(capture);
 
                // Put back in duplicated form
                let duplicate_length = duplicate.len();
                for _ in 0..duplicate_length {
                    input.insert(i, duplicate.pop_back().unwrap())
                }
            }
        }
    }
 
    return output;
}
 
 
fn collect(queue: &VecDeque<char>, start: usize, len: usize) -> VecDeque<char> {
    let mut out = VecDeque::with_capacity(len);
    for i in start .. start + len {
        out.push_back(queue[i])
    }
    out
}
 
fn duplicate(mut substring: VecDeque<char>) -> VecDeque<char> {
    let substring_length = substring.len();
    for i in 0..substring_length {
        let character = substring[i];
        match character.to_digit(10) {
            Some(num) => {
                if num as usize > substring_length {
                    panic!("Infinite answer");
                }
                if i + num as usize >= substring_length {
                    continue; // Overflows past this capture.
                }
 
                substring.remove(i); // Remove number
                let capture = substring.drain(i .. i + num as usize).collect(); // Remove duplicated area
 
                let mut duplicate = duplicate(capture);
 
                // Put back in duplicated form
                let duplicate_length = duplicate.len();
                for _ in 0..duplicate_length {
                    substring.insert(i, duplicate.pop_back().unwrap())
                }
            }
            _ => {}
        }
    }
 
    // Is this seriously the best way to do this in Rust?
    let mut out = substring.clone();
    out.append(&mut substring);
    return out
}

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

Test 6

Group: 1, 2

Verdict: ACCEPTED

Test 7

Group: 1, 2

Verdict: WRONG ANSWER

Test 8

Group: 2

Verdict: ACCEPTED

Test 9

Group: 2

Verdict: WRONG ANSWER

Test 10

Group: 2

Verdict: WRONG ANSWER

Test 11

Group: 2

Verdict: ACCEPTED

Test 12

Group: 2

Verdict: ACCEPTED

Test 13

Group: 2

Verdict: ACCEPTED

Test 14

Group: 2

Verdict: ACCEPTED