DEV Community

Discussion on: Daily Challenge #243 - Redacted!

View post
Collapse
 
qm3ster profile image
Mihail Malo • • Edited

Rust

Assuming that replacement with X is per character.

fn same(bad: &str, real: &str) -> bool {
    bad.len() == real.len()
        && bad
            .chars()
            .zip(real.chars())
            .all(|(b, r)| b == r || (b == 'X' && r != '\n'))
}

yay, a oneliner

With nightly feature 

#![feature(iter_order_by)]
fn same(bad: &str, real: &str) -> bool {
    bad.len() == real.len()
        && bad
            .chars()
            .eq_by(real.chars(), |b, r| b == r || (b == 'X' && r != '\n'))
}

When you're a caveman and reimplement all: 

fn same(bad: &str, real: &str) -> bool {
    if bad.len() != real.len() {
        return false;
    }
    for (b, r) in bad.chars().zip(real.chars()) {
        if b != r && (b != 'X' || r == '\n') {
            return false;
        }
    }
    true
}

When you're a caveman and reimplement .zip() 

fn same(bad: &str, real: &str) -> bool {
    if bad.len() != real.len() {
        return false;
    }
    let mut bad = bad.chars();
    let mut real = real.chars();
    while let (Some(b), Some(r)) = (bad.next(), real.next()) {
        if b != r && (b != 'X' || r == '\n') {
            return false;
        }
    }
    true
}

(none of the latter ones give better performance, only worse)