balanced symbols

balanced.rs

#[macro_use]
extern crate lazy_static;
use std::collections::HashMap;

lazy_static!(
    static ref MAPPING: HashMap<char, char> = [('}', '{'), (')', '('), (']', '[')]
        .iter()
        .cloned()
        .collect();
);

fn main() {
    let inputs = ["{(})[]({{)}}", "{]][)", "{{()}}", "{{}}([)]", "(()))))){}"];
    let result: Vec<_> = inputs
        .iter()
        .map(|inp| is_balanced(inp))
        .map(|res| if res { "YES" } else { "NO" })
        .collect();
    
    for (i, r) in result.iter().enumerate() {
        println!("{} => {}", r, inputs[i]);
    }
}

fn is_balanced(input: &str) -> bool {
    let mut stack = Vec::new();

    for c in input.chars() {
        match c {
            '{' | '(' | '[' => stack.push(c),
            '}' | ')' | ']' => {
                if let Some(cr) = MAPPING.get(&c) {
                    if let Ok(idx) = find_elem(&stack, *cr) {
                        stack.remove(idx);
                    } else {
                        return false;
                    }
                }
            }
            _ => continue,
        }
    }
    stack.is_empty()
}

fn find_elem(vector: &[char], c: char) -> Result<usize, &str> {
    for (idx, v) in vector.iter().enumerate() {
        if *v == c {
            return Ok(idx);
        }
    }
    Err("Char not found !")
}