题解 | #识别有效的IP地址和掩码并进行分类统计#

use std::io::{self, *};

struct IpAddr {
    ip: u32,
    mask: u32
}

impl IpAddr {
    fn is_valid_ip(&mut self, ip: &str) -> bool {
        let mut ipv: Vec<u8>= vec![];
        for i in ip.split(".") {
            if let Ok(j) = i.parse::<u8>() {ipv.push(j)} else {return false} 
        }
        if ipv.len() != 4 {return false}
        self.ip = ((ipv[0] as u32) << 24) + ((ipv[1] as u32) << 16) + ((ipv[2] as u32) << 8) + (ipv[3] as u32);
        true
    }
    
    fn is_other(&self) -> bool {
        let a = self.ip >> 24;
        if a == 0 || a == 127 {true} else {false}
    }

    fn is_valid_mask(&mut self, ip: &str) -> bool {
        let mut ipv: Vec<u8>= vec![];
        for i in ip.split(".") {
            if let Ok(j) = i.parse::<u8>() {ipv.push(j)} else {return false} 
        }
        if ipv.len() != 4 {return false}
        self.mask = ((ipv[0] as u32) << 24) + ((ipv[1] as u32) << 16) + ((ipv[2] as u32) << 8) + (ipv[3] as u32);
        if (self.mask << self.mask.count_ones()) != 0 {return false}
        true
    }

    fn is_private(&self) -> bool {
        let a = self.ip >> 24;
        let b = (self.ip >> 16) as u8;
        if a == 10 || a == 172 && 16 <= b && b <= 31 || a == 192 && b == 168 {true} else {false}
    }

    fn classify(&self) -> char {
        let a = self.ip >> 24;
        match a {
            n if 1 <= n && n <= 126 => 'A',
            n if 128 <= n && n <= 191 => 'B',
            n if 192 <= n && n <= 223 => 'C',
            n if 224 <= n && n <= 239 => 'D',
            n if 240 <= n && n <= 255 => 'E',
            _ => 'O',
        }
    }
}

fn main() {
    let stdin = io::stdin();
    let mut a = 0;
    let mut b = 0;
    let mut c = 0;
    let mut d = 0;
    let mut e = 0;
    let mut err = 0;
    let mut private = 0;
    unsafe {
        for line in stdin.lock().lines() {
            let ll = line.unwrap();
            let mut addrs = ll.split("~");

            let mut ip = IpAddr {ip: 0, mask: 0};
            if !ip.is_valid_ip(addrs.next().unwrap()) {
                err += 1;
            } else if ip.is_other() {
                continue
            } else if !ip.is_valid_mask(addrs.next().unwrap()) {
                err += 1;
                continue
            }
            let res = ip.classify();
            match ip.classify() {
                'A' => a += 1,
                'B' => b += 1,
                'C' => c += 1,
                'D' => d += 1,
                'E' => e += 1,
                _ => {}
            }
            if ip.is_private() {private += 1}
        }
        print!("{} {} {} {} {} {} {}", a, b, c, d, e, err, private);
    }
}