Rust: codewars的Sum by Factors

算法要求：
对一个数组，如[12,15],首先对每个元素进行质因数分解，
比如，12 =2*2*3，有质因数2，3。
15 =3*5，有质因数3，5。
则数组有不同质因数2，3，5。
那么，按从小到大的顺序：2的质因数有12；3的质因数有：12、15；5的质因数有：15。
则可以输出[(2,12),(3,12+15),(5,15)] =>简化[(2,12),(3,27),(5,15)] .

注意，负整数的质因数和对应的正整数的质因数相同。

一、我的解法

use std::collections::{HashMap, HashSet};
fn sum_of_divided(l: Vec<i64>) -> Vec<(i64, i64)> {
    // your code
    //10-6
    //let mut result: Vec<(i64, i64)> = Vec::new();
    // 2: 有2质因数的和， 3：有3质因数的和
    println!("l:{:?}",l);
    let mut data: HashMap<i64, Vec<i64>> = HashMap::new();

    l.clone()
        .iter_mut()
        .map(|x| {
            prime_factors((*x).abs())
                .iter()
                .map(|w| {
                    if data.contains_key(w) {
                        data.get_mut(w).unwrap().push(*x);
                    } else {
                        data.insert(*w, vec![*x]);
                    }
                    w
                })
                .collect::<Vec<_>>()
                .len() as i64

        })
        .collect::<Vec<i64>>();
    let result: HashMap<i64, i64> = data.clone()
        .into_iter()
        .map(|(k, v)| (k,v.iter().sum()))
        .collect();
    sort_vec(result)
}
fn sort_vec(data: HashMap<i64, i64>) -> Vec<(i64, i64)> {
    //let mut output: Vec<(i64, i64)> = Vec::new();
    let mut ky: Vec<i64> = data.keys().into_iter().map(|&x| x).collect();
    ky.sort();
    ky.into_iter().map(|x| (x, *(data.get(&x).unwrap()))).collect::<Vec<(i64, i64)>>()

}
fn is_prime(n: i64) -> bool {
    !(2..(n).abs()).any(|x| n % x == 0)
}
fn prime_factors(n: i64) -> Vec<i64> {
    // your code
    if is_prime(n) {
        return vec![n];
    }
    let mut m = n.abs();
    let mut output: Vec<i64> = Vec::new();
    for i in 2..n.abs() + 1 {
        if m < i {
            break;
        }
        if !is_prime(i) {
            continue;
        }
        while m % i == 0i64 {
            if !output.contains(&i) {
                output.push(i);
            }
            m = m / i;
        }
    }
    output.sort();
    output
    //println!("output:{:?}", output);
}

二、精彩的解法

1、

use std::collections::{BTreeSet, HashSet};

fn prime_factors(mut n: i64) -> HashSet<i64> {
    let mut i = 2;
    let mut res = HashSet::new();
    while i <= n / i {
        while n % i == 0 {
            res.insert(i);
            n /= i;
        }
        i += 1;
    }
    if n > 1 {
        res.insert(n);
    }
    res
}

fn sum_of_divided(l: Vec<i64>) -> Vec<(i64, i64)> {
    l.iter()
        .flat_map(|&x| prime_factors(x.abs()))
        .collect::<BTreeSet<_>>()
        .into_iter()
        .map(|p: i64| (p, l.iter().cloned().filter(|x| x % p == 0).sum())).collect()
}

2、

fn is_prime(&x: &i64) -> bool {
  (2..).take_while(|p| p*p <= x).all(|p| x % p != 0)
}

fn sum_of_divided(l: Vec<i64>) -> Vec<(i64, i64)> {
  let mx = l.iter().map(|&x| x.abs()).max().unwrap_or(0);
  (2..)
    .take_while(|&p| p <= mx)
    .filter(is_prime)
    .filter_map(|p| {
      let mut nums = l.iter().cloned().filter(|x| x.abs() % p == 0).peekable();
      nums.peek().cloned().map(|_| (p, {nums}.sum()))
    })
    .collect()
}

3、

fn sum_of_divided(l: Vec<i64>) -> Vec<(i64, i64)> {
    if l.len() == 0 { return vec![] }
    let max = l.iter().max_by_key(|x| x.abs()).unwrap().abs();
    (2i64..).filter(|&x| is_prime(x)).take_while(|&x| x <= max).fold(Vec::new(), |mut acc, prime| {
        if l.iter().filter(|&i| i % prime == 0).count() > 0 {
            acc.push((prime, l.iter().filter(|&i| i % prime == 0).sum()));
        }        
        acc
    })

}

fn is_prime(n: i64) -> bool {
    if n == 2 { return true; }
    if n < 3 { return false; }
    if n % 2 == 0 { return false; }
    let sqrt_limit = (n as f64).sqrt() as i64;
    let mut i: i64 = 3;
    while i <= sqrt_limit {
       if n % i == 0 { return false; }   
       i += 2;
    }
    true
}