Rust: codewars的Simple Substitution Cipher Helper算法题、N种不简单的解法集

codewars是一个不错的刷题的网站，特别是对于rust爱好者而者，资源稀缺，是打发时光的利器。

今天不是专门安利codewars而来，主要是谈一道简单的加密和解密算法题。
说明：来源于codewars，Simple Substitution Cipher Helper。

一、要求如下：

其实就是26个字母，打乱后，但一一对应。要求对任一字符串，能进行加密和解密。

比如

let map1 = "abcdefghijklmnopqrstuvwxyz";let map2 = "etaoinshrdlucmfwypvbgkjqxz";let cipher = Cipher::new(map1, map2);cipher.encode("abc") // => "eta"cipher.encode("xyz") // => "qxz"cipher.encode("aeiou") // => "eirfg"cipher.decode("eta") // => "abc"cipher.decode("qxz") // => "xyz"cipher.decode("eirfg") // => "aeiou"

如果超出26个字母以外的字符，不加密。即”好”=》“好”

二、N种不同的算法，大开眼界

只能说，牛人太多，爽爽爽！这个是最好的教材。除本法提交的算法外，在此选集了近10种codewars中的精彩的解法，供平时学习。

1、个人提交的算法

use std::collections::HashMap;struct Cipher {    encode: HashMap<String, String>,    decode: HashMap<String, String>,}impl Cipher {    fn new(map1: &str, map2: &str) -> Cipher {        let _encode = map1.chars()            .map(|x| x.to_string())            .zip(map2.chars().map(|y| y.to_string()))            .collect::<HashMap<String, String>>();        let _decode = map2.chars()            .map(|x| x.to_string())            .zip(map1.chars().map(|y| y.to_string()))            .collect::<HashMap<String, String>>();        Cipher {            encode: _encode,            decode: _decode,        }    }    fn encode(&self, string: &str) -> String {        let mut _strs = String::from("");        let strs: Vec<_> = string.chars()            .map(|x| match self.encode.get(&x.to_string()) {                Some(s) => _strs.push_str(s),                _ => _strs.push_str(&x.to_string()),            })            .collect();        _strs    }    fn decode(&self, string: &str) -> String {        let mut _strs = String::from("");        let strs: Vec<_> = string.chars()            .map(|x| match self.decode.get(&x.to_string()) {                Some(s) => _strs.push_str(s),                _ => _strs.push_str(&x.to_string()),            })            .collect();        _strs    }}

2、codewars的最佳算法

struct Cipher {  map: Vec<(char, char)>}impl Cipher {  fn new(map1: &str, map2: &str) -> Cipher {    Cipher {      map: map1.chars().zip(map2.chars()).collect()    }  }  fn encode(&self, string: &str) -> String {    string.chars().map(|c| self.map.iter().find(|x| x.0 == c).map_or(c, |y| y.1)).collect()  }  fn decode(&self, string: &str) -> String {    string.chars().map(|c| self.map.iter().find(|x| x.1 == c).map_or(c, |y| y.0)).collect()  }}

3、其它算法

use std::collections::HashMap;struct Cipher {  encode_map: HashMap<char, char>,  decode_map: HashMap<char, char>,}impl Cipher {  fn new(map1: &str, map2: &str) -> Cipher {    let mut encode_map = HashMap::new();    encode_map.extend(map1.chars().zip(map2.chars()));    let mut decode_map = HashMap::new();    decode_map.extend(map2.chars().zip(map1.chars()));    Cipher { encode_map: encode_map, decode_map: decode_map }  }  fn encode(&self, string: &str) -> String {    string.chars().map(|c| self.encode_map.get(&c).map_or(c, |v| *v)).collect()  }  fn decode(&self, string: &str) -> String {    string.chars().map(|c| self.decode_map.get(&c).map_or(c, |v| *v)).collect()  }}

4、BTreeMap

use std::collections::BTreeMap;struct Cipher {  // We need a bidirectional cipher implementation, with dictionary per direction.  // BTreeMap should likely work faster than HashMap with simplest hasher in our case.  etree: BTreeMap<char, char>,  dtree: BTreeMap<char, char>,}impl Cipher {  fn new(map1: &str, map2: &str) -> Cipher {    Cipher {      // Hopefully BTreeMap is created balanced.      etree: map1.chars().zip(map2.chars()).collect(),      dtree: map2.chars().zip(map1.chars()).collect(),    }  }  // Here be dragons, krakens, sandworms and impaired (de-)referencing conventions.  fn encode(&self, string: &str) -> String {    string.chars().map(|c| self.etree.get(&c).cloned().unwrap_or(c)).collect()  }  fn decode(&self, string: &str) -> String {    string.chars().map(|c| self.dtree.get(&c).cloned().unwrap_or(c)).collect()  }}

5、String

struct Cipher {  map1: String,  map2: String,}impl Cipher {  fn new(map1: &str, map2: &str) -> Cipher {    Cipher { map1: map1.into(), map2: map2.into()}  }  fn encode(&self, string: &str) -> String {    string.chars().map(    |c| {      match self.map1.find(c) {        Some(i) => self.map2.chars().nth(i).unwrap(),        _ => c      }    }    ).collect()  }  fn decode(&self, string: &str) -> String {    string.chars().map(    |c| {      match self.map2.find(c) {        Some(i) => self.map1.chars().nth(i).unwrap(),        _ => c      }    }    ).collect()  }}

6、Vec

struct Cipher {  from: Vec<u8>,  to: Vec<u8>,}impl Cipher {  fn new(map1: &str, map2: &str) -> Cipher {    Cipher {      from: map1.as_bytes().to_vec(),      to: map2.as_bytes().to_vec(),    }  }  fn encode(&self, string: &str) -> String {    string.chars()      .map(|c| self.from.iter().position(|&f| f == c as u8).map_or(c, |p| self.to[p] as char))      .collect()  }  fn decode(&self, string: &str) -> String {    string.chars()      .map(|c| self.to.iter().position(|&f| f == c as u8).map_or(c, |p| self.from[p] as char))      .collect()  }}

7、

use std::collections::HashMap;fn get_default(m: &HashMap<char,char>,k: &char) -> char {    match m.get(k) {        Some(val) => *val,        None => *k    }}struct Cipher {  encoding: HashMap<char,char>,  decoding: HashMap<char,char>}impl Cipher {  fn new(map1: &str, map2: &str) -> Cipher {        let mut encoding = HashMap::new();        let mut decoding = HashMap::new();        for (x,y) in map1.chars().zip(map2.chars()) {            encoding.insert(x,y);            decoding.insert(y,x);        }        Cipher{encoding:encoding,decoding:decoding}  }  fn encode(&self, string: &str) -> String {    string.chars().map(|c| get_default(&self.encoding,&c).to_string())      .collect::<Vec<String>>().join("")  }  fn decode(&self, string: &str) -> String {    string.chars().map(|c| get_default(&self.decoding,&c).to_string())      .collect::<Vec<String>>().join("")  }}

8、

use std::collections::HashMap;struct Cipher {  encode: HashMap<char, char>,  decode: HashMap<char, char>,}fn _code(map: &HashMap<char, char>, string: &str) -> String {    string.chars()      .map(|x| map.get(&x).unwrap_or(&x).clone())      .collect()}impl Cipher {  fn new(map1: &str, map2: &str) -> Cipher {    Cipher {      encode: map1.chars()                .zip(map2.chars())                .collect(),      decode: map2.chars()                .zip(map1.chars())                .collect(),    }  }  fn encode(&self, string: &str) -> String {    _code(&self.encode, string)  }  fn decode(&self, string: &str) -> String {    _code(&self.decode, string)  }}

9、

struct Cipher<'a> {    map1:&'a [u8],    map2:&'a [u8]}impl<'a> Cipher<'a> {    fn new(map1: &'a str, map2: &'a str) -> Cipher<'a> {        Cipher{map1:map1.as_bytes(), map2:map2.as_bytes()}    }    fn encode(&self, string: &str) -> String {        string.bytes()            .map(|b|                 self.map1                    .iter()                    .position(|&m| b==m)                    .and_then(|i| self.map2.get(i))                    .cloned()                    .unwrap_or(b) as char            )            .collect()    }    fn decode(&self, string: &str) -> String {        self.decoder().encode(string)    }    fn decoder(&self) -> Cipher{        Cipher{map1:self.map2, map2:self.map1}    }}

10、

struct Cipher {  table : std::collections::HashMap<char,char>}impl Cipher {  fn new(map1: &str, map2: &str) -> Cipher {    Cipher {      table : map1.chars().zip(map2.chars()).collect()    }  }  fn encode(&self, string: &str) -> String {    string.chars().map(|x| self.table.get(&x).cloned().unwrap_or(x)).collect()  }  fn decode(&self, string: &str) -> String {    string.chars().map(|x| self.decode_char(x)).collect()  }  fn decode_char(&self, c: char) -> char {    self.table.iter().find(|kv| *kv.1 == c).map(|kv| *kv.0).unwrap_or(c)  }}

11、个人认为的最佳解法

use std::collections::HashMap;struct Cipher {  encode: HashMap<char, char>,  decode: HashMap<char, char>}impl Cipher {  fn new(map1: &str, map2: &str) -> Self {    let encode = map1.chars().zip(map2.chars()).collect();    let decode = map2.chars().zip(map1.chars()).collect();    Cipher{encode: encode, decode: decode}  }  fn encode(&self, string: &str) -> String {    string.chars().map(|ref c| *self.encode.get(c).unwrap_or(c)).collect()  }  fn decode(&self, string: &str) -> String {    string.chars().map(|ref c| *self.decode.get(c).unwrap_or(c)).collect()  }}

三、个别点评

看了其它人10种解法外，个人认为第11种解法最佳，思路清晰，代码简单，最为优雅，第10种也差不多，当然，各种优势。

我的解法的思路虽然相同，但用String并不是一个好的选择，过于笨重，增加了不少的代码量。

1、用char代替String

//在上面场景中，HashMap<char, char>较HashMap<String, String>结构更轻巧。fn new(map1: &str, map2: &str) {    let _encode = map1.chars()        .zip(map2.chars())        .collect::<HashMap<char, char>>();}//没有过多的转化

2、使用unwrap_or，可以省了一大段的代码：

    string.chars().map(|ref c| *self.encode.get(c).unwrap_or(c)).collect()