rust_project 0.1.5

upload test
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

use std::env;
use std::process;

use rust_project::Config;

mod spider;
mod utils;
// use crate::spider::spider::run_cmd;
// use spider::run_cmd;


use std::collections::HashMap;
use std::ops::AddAssign;

fn main() {
    spider::run_cmd();
    spider::main2();

    utils::run_cmd();
    utils::util();

    println!("Hello, world!");
    let args: Vec<String> = env::args().collect();
    println!("{:?}", args);

    let config = Config::new(&args).unwrap_or_else(|err| {
        eprintln!("Problem parsing argument:{}", err);
        process::exit(1);
    });

    let query = &config.query;
    let filename = &config.filename;
    println!("-query is <{}>", query);
    println!("-filename is <{}>", filename);

    if let Err(e) = rust_project::run(config) {
        println!("\nApplication error: {}", e);
    }

    let numbers = vec![1, 45, 23, 65, 788, 432, 78, 65, 65, 46, 3, 6543, 23, 65];
    let median = find_median(&numbers);
    match median {
        Some(value) => println!("median:{value}"),
        _ => (),
    }

    let mode = find2(&numbers);
    match mode {
        Some(value) => println!("mode:{value}"),
        _ => (),
    }
}

fn find_median(numbers: &Vec<i32>) -> Option<i32> {
    if numbers.is_empty() {
        return None;
    }
    let mut new_vec = numbers.to_vec();
    new_vec.sort();

    let pos = new_vec.len() / 2;
    Option::from(*new_vec.get(pos).unwrap())
}

fn find2(numbers: &Vec<i32>) -> Option<i32> {
    numbers
        .iter()
        .fold(HashMap::new(), |mut acc, i| {
            acc.entry(i).or_insert(0).add_assign(1);
            acc
        })
        .iter()
        .reduce(
            |current, next| {
                if current.1 < next.1 {
                    next
                } else {
                    current
                }
            },
        )
        .map(|e| **e.0)
}

// # ![feature(slice_group_by)]
// fn find3(numbers: &Vec<i32>) -> Option<i32> {
//     numbers.group_by(|i, j| i == j)
//         .map(|e| (e.first().unwrap(), e.len()))
//         .max_by(|a, b| (*a).1.cmp(&(*b).1))
//         .map(|e| *e.0)
// }