Monistus

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

warning: unused import: `Write`
 --> input/code.rs:4:23
  |
4 | use std::fmt::{Debug, Write};
  |                       ^^^^^

warning: function `parse_line` is never used
  --> input/code.rs:10:4
   |
10 | fn parse_line<'a, T: FromStr + Debug>(line: &'a str) -> impl Iterator<Item = T> + 'a
   |    ^^^^^^^^^^
   |
   = note: `#[warn(dead_code)]` on by default

warning: 3 warnings emitted

use core::panic;
use std::error::Error;

use std::fmt::{Debug, Write};

use std::io::{self};
use std::str::FromStr;
type Result<T> = std::result::Result<T, Box<dyn Error>>;

fn parse_line<'a, T: FromStr + Debug>(line: &'a str) -> impl Iterator<Item = T> + 'a
where
    <T as FromStr>::Err: Debug,
{
    line.split_whitespace()
        .map(|n| n.parse::<T>().expect("wow"))
}
fn rec(mut s: String) -> String {
    while let Some(num_idx) = s.find(|c: char| c.is_numeric()) {
        let num = s.chars().nth(num_idx).unwrap() as usize - '0' as usize;
        s = format!(
            "{}{}",
            &s[..num_idx],
            rec(s[(num_idx + 1)..(num_idx + 1 + num)].repeat(2) + &s[(num_idx + 1 + num)..])
        )
    }
    s
}
fn main() -> Result<()> {
    let mut lines = io::stdin().lines().filter_map(|line| line.ok());
    let s = lines.next().unwrap();
    println!("{}", rec(s));
    Ok(())
}

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

Test 8

Group: 2

Verdict: RUNTIME ERROR

Test 9

Group: 2

Verdict: RUNTIME ERROR

Test 10

Group: 2

Verdict: RUNTIME ERROR

Test 11

Group: 2

Verdict: RUNTIME ERROR

Test 12

Group: 2

Verdict: RUNTIME ERROR

Test 13

Group: 2

Verdict: RUNTIME ERROR

Test 14

Group: 2

Verdict: RUNTIME ERROR