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::<Vec<&str>>();
let lens = words.clone().into_iter().map(|x| x.len()).collect::<Vec<_>>();
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::<Vec<&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<String> =
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::<Vec<_>>()
.join(" ")
}