Rust : codewars的up AND down 算法

codewars中的“up AND down 算法”如下：

1、对于一个字符串s，用空格隔开，并形成一个Vec类型的 vs;
2、对形成的s,要求进行重新顺序排列，满足这个要求：
length vs(0) <=v length vs(1) >= length vs(2) <= length vs(3) >= length (vs4) <= length (vs5)….;
3、如果输入的字符串为空，则输出“”字符串；

一、我的算法

fn arrange(s: &str) -> String {
    // your code
    println!("input:{}",s);
    if s.len()==0{return "".to_string();}
    let mut words = s.split_whitespace().collect::str>>();
    let lens = words.clone().into_iter().map(|x| x.len()).collect::_>>();
    let len = lens.len();

    if len == 1 {
        return (&words[0]).to_string();
    }
    for i in 0..len - 1 {
        for j in 0..len - 1 {
            if i == 0 {
                if j == 1 && &words[0].len() > &words[1].len() {
                    words = swap(words, 0usize, 1usize);
                }
            } else {
                if j % 2 == 0 {
                    if &words[j].len() > &words[j + 1].len() {
                        words = swap(words, j as usize, (j + 1) as usize);
                    }

                } else {
                    if &words[j].len() < &words[j + 1].len() {
                        words = swap(words, j as usize, (j + 1) as usize);
                    }
                }

            }
        }
    }
    let mut c = 0;
    let result =words.iter().fold("".to_string(), |total, x| {
        c += 1;
        match c % 2 == 0 {
            true => total + &x.to_uppercase() + " ",
            _ => total + &x.to_lowercase() + " ",
        }

    });
    (&result).trim().to_string()

}


fn swap(vec: Vec<&str>, i: usize, j: usize) -> Vec<&str> {

    let mut v = vec.clone();
    let len = v.len();
    if len < i + 1 || len < j + 1 {
        panic!("swap: i:{},j:{} is not fit!", i, j);
    }

    if let Some(v_i) = v.get_mut(i) {
        *v_i = &vec[j]; //i_val;
    }
    if let Some(v_j) = v.get_mut(j) {
        *v_j = &vec[i];
    }

    //println!("before swap vec:{:?}", vec);
    //println!("after swap vec:{:?}", v);
    v
}

二、精彩的解法

1、

fn change(mut res : Vec<&str>) -> Vec<&str> {
    let l = res.len();
    for i in 0..l - 1 {
        if (i % 2 != 0 && res[i].len() < res[i + 1].len()) ||
            (i % 2 == 0 && res[i].len() > res[i + 1].len()) {
            let tmp = res[i + 1];
            res[i + 1] = res[i];
            res[i] = tmp;
        }
    }
    res
}

fn arrange(s: &str) -> String {
    if s == "".to_string() {return "".to_string()}
    let a: Vec<&str> = s.split(' ').collect::str>>();
    let e: Vec<&str> = change(a);
    let l = e.len();
    let mut res = vec![];
    for j in 0..l {
        if j % 2 == 0 {res.push(e[j].to_lowercase())}
        else {res.push(e[j].to_uppercase())}
    }
    res.join(" ").to_string()
}

2、

fn arrange(s: &str) -> String {
    let mut words: Vec =
        s.split(' ').map(|w| w.to_string()).collect();
    for i in 0..words.len() {
        if i + 1 < words.len() &&
           ((i & 1 == 0 && words[i].len() > words[i+1].len()) ||
            (i & 1 != 0 && words[i].len() < words[i+1].len())) {
            words.swap(i, i+1);
        }
        if i & 1 == 0 {
            words[i] = words[i].to_lowercase();
        } else {
            words[i] = words[i].to_uppercase();
        }
    }
    words.join(" ")
}

3、

fn arrange(s: &str) -> String {
    let mut v: Vec<&str> = s.split(char::is_whitespace).collect();
    for i in 1..v.len() {
        let do_swap = {
          if i % 2 == 0 {
            v[i].len() > v[i-1].len()
          } else {
            v[i].len() < v[i-1].len()
          }
        };
        if do_swap {
          v.swap(i-1, i);
        }
    }
    v.iter().enumerate()
     .map(|(i, item)|
          if i % 2 == 1 {
            item.to_uppercase()
          } else {
            item.to_lowercase()
          })
     .collect::>()
     .join(" ")
}