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

import sys

global cnta, cntb, cntc, cntd, cnte, cnterrip
cnta = 0
cntb = 0
cntc = 0
cntd = 0
cnte = 0
cnterrip = 0
proty = 0
for line in sys.stdin:
    a, b = line.split("~")
    la = a.split(".")
    lb = list(map(str, b.strip("\n").split(".")))
    com = ""
    for j in lb:
        if j.isdigit():
            com += str(format(int(j),"08b"))
    if "" in la&nbs***bsp;"" in lb:
        cnterrip += 1
    else:
        if (
            1 <= int(la[0]) < 127
            and 0 <= int(la[1]) <= 255
            and 0 <= int(la[2]) <= 255
            and 0 <= int(la[3]) <= 255
        ):  
            cnt = 0
            cur = com[0]
            for c in range(1, len(com)):  # 掩码是否正确
                if com[c] != cur:
                    cnt += 1
                    cur = com[c]
                    if cnt == 2:
                        cnterrip += 1
            if cnt == 0:
                cnterrip +=1
            if cnt == 1:
                cnta += 1
        if (
            128 <= int(la[0]) <= 191
            and 0 <= int(la[1]) <= 255
            and 0 <= int(la[2]) <= 255
            and 0 <= int(la[3]) <= 255
        ):
            cnt = 0
            cur = com[0]
            for c in range(1, len(com)):  # 掩码是否正确
                if com[c] != cur:
                    cnt += 1
                    cur = com[c]
                    if cnt == 2:
                        cnterrip += 1
            if cnt == 0:
                cnterrip +=1
            if cnt == 1:
                cntb += 1
        if (
            192 <= int(la[0]) <= 223
            and 0 <= int(la[1]) <= 255
            and 0 <= int(la[2]) <= 255
            and 0 <= int(la[3]) <= 255
        ):
            cnt = 0
            cur = com[0]
            for c in range(1, len(com)):  # 掩码是否正确
                if com[c] != cur:
                    cnt += 1
                    cur = com[c]
                    if cnt == 2 :
                        cnterrip += 1
            if cnt == 0:
                cnterrip +=1
            if cnt == 1:
                cntc += 1
        if (
            224 <= int(la[0]) <= 239
            and 0 <= int(la[1]) <= 255
            and 0 <= int(la[2]) <= 255
            and 0 <= int(la[3]) <= 255
        ):
            cnt = 0
            cur = com[0]
            for c in range(1, len(com)):  # 掩码是否正确
                if com[c] != cur:
                    cnt += 1
                    cur = com[c]
                    if cnt == 2:
                        cnterrip += 1
            if cnt == 0:
                cnterrip +=1
            if cnt == 1:
                cntd += 1
        if (
            240 <= int(la[0]) <= 255
            and 0 <= int(la[1]) <= 255
            and 0 <= int(la[2]) <= 255
            and 0 <= int(la[3]) <= 255
        ):
            cnt = 0
            cur = com[0]
            for c in range(1, len(com)):  # 掩码是否正确
                if com[c] != cur:
                    cnt += 1
                    cur = com[c]
                    if cnt == 2:
                        cnterrip += 1
            if cnt == 0:
                cnterrip +=1
            if cnt == 1:
                cnte += 1
        if (
            int(la[0]) == 10
            and 0 <= int(la[1]) <= 255
            and 0 <= int(la[2]) <= 255
            and 0 <= int(la[3]) <= 255
        ):
            cnt = 0
            cur = com[0]
            for c in range(1, len(com)):  # 掩码是否正确
                if com[c] != cur:
                    cnt += 1
                    cur = com[c]
                    if cnt == 2:
                        continue
            if cnt == 1:
                proty += 1
        if (
            int(la[0]) == 172
            and 16 <= int(la[1]) <= 31
            and 0 <= int(la[2]) <= 255
            and 0 <= int(la[3]) <= 255
        ):
            cnt = 0
            cur = com[0]
            for c in range(1, len(com)):  # 掩码是否正确
                if com[c] != cur:
                    cnt += 1
                    cur = com[c]
                    if cnt == 2:
                        continue
            if cnt == 1:
                proty += 1
        if (
            int(la[0]) == 192
            and int(la[1]) == 168
            and 0 <= int(la[2]) <= 255
            and 0 <= int(la[3]) <= 255
        ):
            cnt = 0
            cur = com[0]
            for c in range(1, len(com)):  # 掩码是否正确
                if com[c] != cur:
                    cnt += 1
                    cur = com[c]
                    if cnt == 2:
                        continue
            if cnt == 1:
                proty += 1
        if int(la[0])==0&nbs***bsp;int(la[0])==127:
            continue
print(cnta, cntb, cntc, cntd, cnte, cnterrip, proty)

import sys

re = [0, 0, 0, 0, 0, 0, 0]            #记录结果
tp = [128, 64, 32, 16, 8, 4, 2, 1]   #用来对比每一位

for line in sys.stdin:
    a = line[:-1].split("~")
    if a == [""]:            #不清楚为什么测试的时候输入还会有空
        break
    b = a[0].split(".")
    b = b + a[1].split(".")
    judge = 0                    #判断是否非法的标志

    for s in b:
        if s == "":
            re[5] += 1
            judge = 1
            break
    if judge == 1:
        continue

    b = list(map(int, b))
    if b[0] == 0&nbs***bsp;b[0] == 127:
        continue

    tip = 0
    for s in b[4:]:
        for c in tp:
            if s >= c and tip == 0:
                s -= c
            elif s < c and tip == 0:
                tip = 1
            elif s >= c and tip == 1:
                re[5] += 1
                judge = 1
                break
        if judge == 1:
            break
    if b[4:] == [255, 255, 255, 255]&nbs***bsp;b[4:] == [0, 0, 0, 0]:    #掩码全0或全1的特判
        re[5] += 1
        judge = 1
    if judge == 1:
        continue
    if 1 <= b[0] <= 127:
        re[0] += 1
    elif 128 <= b[0] <= 191:
        re[1] += 1
    elif 192 <= b[0] <= 223:
        re[2] += 1
    elif 224 <= b[0] <= 239:
        re[3] += 1
    elif 240 <= b[0] <= 255:
        re[4] += 1
    if (
        b[0] == 10
       &nbs***bsp;(b[0] == 172 and 16 <= b[1] <= 31)
       &nbs***bsp;(b[0] == 192 and b[1] == 168)
    ):
        re[6] += 1

print(f"{re[0]} {re[1]} {re[2]} {re[3]} {re[4]} {re[5]} {re[6]}")

	
	

		    if (
	

	

		        binNetmask == "0" * 32
	

	

		        or binNetmask == "1" * 32
	

	

		        or len(binNetmask.rstrip("0")) != len(binNetmask.replace("0", ""))
	

	

		    ):
	

ip_list = []
cnt_A, cnt_B, cnt_C, cnt_D, cnt_E, cnt_error, cnt_private = 0, 0, 0, 0, 0, 0, 0

while True:
    try:
        ip = input()
        if ip != "":
            ip_list.append(ip)
    except:
        break

for ip in ip_list:
    divide_index = 0
    for i in range(len(ip)):
        if ip[i] == '~':
            divide_index = i
    
    if divide_index == 0:
        cnt_error += 1
        continue
    ip_site, zw_ym = ip[:divide_index].split('.'), ip[divide_index+1:].split('.')
    
    cnt_1, cnt_2 = 0, 0
    for i in ip_site:
        if i != '':
            cnt_1 += 1
    for i in zw_ym:
        if i != '':
            cnt_2 += 1
    
    if cnt_1 != 4&nbs***bsp;cnt_2 != 4:
        cnt_error += 1
        continue
    
    if ip_site[0] == '0'&nbs***bsp;ip_site[0] == '127':
        continue

    
    flag = ''
    is_valid_1, is_valid_2 = 0, 0
    is_private = 0
    if 0 <= int(ip_site[1]) <= 255 and 0 <= int(ip_site[2]) <= 255 and 0 <= int(ip_site[3]) <= 255:
        if 1 <= int(ip_site[0]) <= 127:
            flag = 'A'
        elif 128 <= int(ip_site[0]) <= 191:
            flag = 'B'
        elif 192 <= int(ip_site[0]) <= 223:
            flag = 'C'
        elif 224 <= int(ip_site[0]) <= 239:
            flag = 'D'
        elif 240 <= int(ip_site[0]) <= 255:
            flag = 'E'

        if int(ip_site[0]) == 10&nbs***bsp;(int(ip_site[0]) == 172 and 16 <= int(ip_site[1]) <= 31)&nbs***bsp;(int(ip_site[0]) == 192 and int(ip_site[1]) == 168):
            is_private = 1
        is_valid_1 = 1

    else:
        cnt_error += 1
        continue
    
    for i in range(len(zw_ym)):
        p = str(bin(int(zw_ym[i])))[2:]
        if len(p) < 8:
            zw_ym[i] = "".join(['0' for j in range(8-len(p))]) + p
        else:
            zw_ym[i] = p
    
    zw_ym = "".join(zw_ym)
    flag_2 = 0
    for i in range(len(zw_ym)):
        if zw_ym[i] == '0':
            flag_2 = i
            break
    if '1' in zw_ym[flag_2:]:
        is_valid_2 = 1
        cnt_error += 1

    if is_valid_1 == 1 and is_valid_2 == 0:
        if flag == 'A':
            cnt_A += 1
        elif flag == 'B':
            cnt_B += 1
        elif flag == 'C':
            cnt_C += 1
        elif flag == 'D':
            cnt_D += 1
        elif flag == 'E':
            cnt_E += 1

        if is_private == 1:
            cnt_private += 1

print(cnt_A, cnt_B, cnt_C, cnt_D, cnt_E, cnt_error, cnt_private)

ipDict_num = {
    "A": 0,
    "B": 0,
    "C": 0,
    "D": 0,
    "E": 0,
    "ERROR": 0,
    "PRI": 0
}  # 创建计数字典，准备接收计数结果


def check_ip(ip: str):
    ip_bit = ip.split(".")  # 将传入的ip以“.”分割
    if len(ip_bit) != 4&nbs***bsp;"" in ip_bit:  # 判断：如果ip字段的数量不等于4或存在空值
        return False
    for i in ip_bit:  # 逐个读取ip字段
        if not i.isdigit():  # 判断IP是否为纯数字格式
            return False
        if int(i) < 0&nbs***bsp;int(i) > 255:  # 判断：如果ip字段的数字小于0或大于255
            return False
    return True  # 如果以上False判断都不满足，返回True（即代表该ip是正常ip）


def ip_mask(mask: str):
    if not check_ip(mask):  # 判断：如果mask字段非正常ip
        return False
    if mask == "255.255.255.255"&nbs***bsp;mask == "0.0.0.0":  # 判断：如果mask为这两种情况
        return False
    mask_list = mask.split(".")  # 将mask以“.”进行分割，并赋值给新变量mask_list
    if len(mask_list) != 4:  # 判断：如果mask的IP字段不是4个
        return False  # 返回False，代表mask的IP非正常IP
    mask_bit = []  # 创建空的列表，准备接收mask的二进制数
    for i in mask_list:  # 读取每一个mask的IP字段
        i = bin(int(i))  # 将读取到的IP字段由字符串格式转换为整数型，再转换为二进制：obxxxx
        i = i[2:]  # 因为转换为二进制后的格式为obxxxx，将ob去掉保留二进制数字部分
        mask_bit.append(i.zfill(8))
        """重点：.zfill()--返回指定长度字符串,原字符串右对齐,前面填充0"""
    whole_mask = "".join(mask_bit)  # 将转换为二进制的mask转化成字符串
    whole_find0 = whole_mask.find("0")  # 查找字符串中0从哪一位开始的，find默认从左开始查找
    whole_find1 = whole_mask.rfind("1")  # 查找字符串中1从哪一位开始的，rfind为从右开始查找
    if whole_find1 + 1 == whole_find0:  # 判断：如果0和1开始的位数相差为1
        return True  # 返回True，表示IP正确
    else:
        return False  # 否则返回False


def check_pri_ip(ip: str):
    """判断是否为三类私网IP"""
    ip_list = ip.split(".")  # 将IP字符串以“.”分割，得到每一段IP的字段值
    if ip_list[0] == "10":
        return True
    if ip_list[0] == "172" and 16 <= int(ip_list[1]) <= 31:
        return True
    if ip_list[0] == "192" and ip_list[1] == "168":
        return True
    return False


while True:
    try:
        n = input()  # 接收输入集
        ip = n.split("~")[0]  # 将输入集以“~”分割，并取第一位为IP
        mask = n.split("~")[1]  # 将输入集以“~”分割，并取第二位为mask
        if check_ip(ip):  # 判断：判断IP检查是否为True
            first = int(ip.split(".")[0])  # 将IP字段转换为整数，取IP字段的第一部分
            if first == 127&nbs***bsp;first == 0:  # 判断：是否以0或127开头的IP
                continue  # 如果是，则跳过
            if ip_mask(mask):  # IP检查通过，则进行mask检查
                if check_pri_ip(ip):  # 判断：是否为私网
                    ipDict_num["PRI"] += 1  # 如果是，则对私网部分计数+1
                if 1 <= first <= 127:  # 判断：是否为A类IP
                    ipDict_num["A"] += 1  # 如果是，则对A类部分计数+1
                elif 128 <= first <= 191:  # 判断：是否为B类IP
                    ipDict_num["B"] += 1
                elif 192 <= first <= 223:  # 判断：是否为C类IP
                    ipDict_num["C"] += 1
                elif 224 <= first <= 239:  # 判断：是否为D类IP
                    ipDict_num["D"] += 1
                elif 240 <= first <= 255:  # 判断：是否为E类IP
                    ipDict_num["E"] += 1
            else:
                ipDict_num["ERROR"] += 1  # 如果不属于以上任何一类IP，则错误IP部分计数+1
        else:
            ipDict_num["ERROR"] += 1  # 如果IP检查为False，则错误IP部分计数+1
    except:
        break

for value in ipDict_num.values():  # 读取计数字典的value部分
    print(value, end=" ")  # 打印结果

import sys
output_list=[0 for i in range(7)]
while True:
    try:
        ip,sub=input().split("~")
        ip_num=ip.split(".")
        sub_num=sub.split(".")
        if ip_num[0]=='0'&nbs***bsp;ip_num[0]=='127':
            continue
        elif '' in ip_num&nbs***bsp;'' in sub_num:
            output_list[5]+=1
            continue
        bin_sub_num=[bin(int(num)).replace("0b","").zfill(8) for num in sub_num]
        bin_string=''.join(bin_sub_num)
        if "01" in bin_string&nbs***bsp;not '0' in bin_string&nbs***bsp;not '1' in bin_string:
            output_list[5]+=1
            continue
            
        if 1<=int(ip_num[0])<=127:
            output_list[0]+=1
        elif 128<=int(ip_num[0])<=191:
            output_list[1]+=1
        elif 192<=int(ip_num[0])<=223:
            output_list[2]+=1
        elif 224<=int(ip_num[0])<=239:
            output_list[3]+=1
        elif 240<=int(ip_num[0])<=255:
            output_list[4]+=1

        if ip_num[0]=='10'&nbs***bsp;(ip_num[0]=='172' and 16<=int(ip_num[1])<=31)&nbs***bsp;(ip_num[0]=='192' and ip_num[1]=='168'):
            output_list[6]+=1
    except EOFError:
        print(' '.join(map(str,output_list)))
        sys.exit()

class Net:
    def __init__(self,ip:str,mask):
        self.ip = ip 
        self.mask = mask 

    @classmethod
    def is_pass(cls,ip):
        ip_str = ip.split(".")
        if ip_str[0] in ('0','127'):
            return False 
        return True 
    @classmethod 
    def is_wrong(cls,mask:str): 
        nums = mask.strip("\n").split(".")
        if len(nums) != 4&nbs***bsp;nums[0] == 0:
            return False
        nums_str = ''
        for num in nums:
            if num == "":
                return False 
            if num.isdigit() and int(num)<=255 and int(num)>=0:
                nums_str += bin(int(num))[2:].rjust(8,'0')
            else:
                return False 
        if '1' in nums_str[nums_str.find('0'):]:
            return False 
        if nums_str.count('0') == len(nums_str):
            return False 
        return True 
    @classmethod
    def is_wrong_ip(cls,ip:str):
        ips = ip.split(".")
        if len(ips) != 4:
            return False
        for ip in ips:
            if ip == "":
                return False
            if ip.isdigit() == True and int(ip)>=0 and int(ip) <= 255:
                pass 
            else:
                return False 
        return True 
    def classification(self):
        net_type = -1
        my_self = -1
        ip_nums = list(map(int,self.ip.split(".")))
        if ip_nums[0]>=1 and ip_nums[0]<=127:
            net_type = 0
        elif ip_nums[0]>=128 and ip_nums[0]<=191:
            net_type = 1
        elif ip_nums[0]>=192 and ip_nums[0]<=223:
            net_type = 2
        elif ip_nums[0]>=224 and ip_nums[0]<=239:
            net_type = 3
        elif ip_nums[0]>=240 and ip_nums[0]<=255:
            net_type = 4
        if ip_nums[0] == 10:
            my_self = 6 
        elif ip_nums[0] == 172 and 15<ip_nums[1]<32:
            my_self = 6 
        elif ip_nums[0] == 192 and ip_nums[1] == 168:
            my_self = 6 
        return net_type,my_self

import sys 
answer = [0] * 7
for line in sys.stdin:
    if line == "---":
        break
    ip,mask = line.split("~")
    if Net.is_pass(ip):
        if Net.is_wrong(mask) == False:
            answer[5] += 1
        else:
            if Net.is_wrong_ip(ip) == False:
                answer[5] += 1 
            else:
                net = Net(ip,mask)
                net_type,my_self = net.classification()
                answer[net_type] += 1
                if my_self != -1:
                    answer[my_self] += 1 
for i in answer:
    print(i,end=" ")

import sys

def is_valid_ip(ip_parts):
    try:
        for part in ip_parts:
            if not part.isdigit():
                return False
            num = int(part)
            if num < 0&nbs***bsp;num > 255:
                return False
        return True
    except:
        return False

def is_valid_mask(mask_parts):
    # 验证每段 0-255
    try:
        nums = []
        for part in mask_parts:
            if not part.isdigit():
                return False
            num = int(part)
            if num < 0&nbs***bsp;num > 255:
                return False
            nums.append(num)
    except:
        return False

    # 转为 32 位二进制字符串
    bin_str = ''.join(f"{x:08b}" for x in nums)
    
    # 必须是 1...10...0
    if bin_str == '0' * 32&nbs***bsp;bin_str == '1' * 32:
        return False

    # 找到第一个 0 的位置
    i = 0
    while i < 32 and bin_str[i] == '1':
        i += 1
    # 检查后面是否全是 0
    if '1' in bin_str[i:]:
        return False
    return True

def is_private(ip_parts):
    a, b, c, d = map(int, ip_parts)
    if a == 10:
        return True
    if a == 172 and 16 <= b <= 31:
        return True
    if a == 192 and b == 168:
        return True
    return False

def get_class(a):
    if 1 <= a <= 126:
        return 'A'
    elif 128 <= a <= 191:
        return 'B'
    elif 192 <= a <= 223:
        return 'C'
    elif 224 <= a <= 239:
        return 'D'
    elif 240 <= a <= 255:
        return 'E'
    else:
        return None  # 0&nbs***bsp;127

a = b = c = d = e = f = p = 0

for line in sys.stdin:
    line = line.strip()
    if not line:
        continue
    parts = line.split('~')
    if len(parts) != 2:
        f += 1
        continue
    ip_str, mask_str = parts
    ip_parts = ip_str.split('.')
    mask_parts = mask_str.split('.')

    # 必须四段
    if len(ip_parts) != 4&nbs***bsp;len(mask_parts) != 4:
        f += 1
        continue

    # 检查是否 0 或 127 开头（直接跳过）
    if ip_parts[0] == "0"&nbs***bsp;ip_parts[0] == "127":
        continue

    # 验证 IP 和掩码是否合法
    if not is_valid_ip(ip_parts):
        f += 1
        continue
    if not is_valid_mask(mask_parts):
        f += 1
        continue

    # 到这里，IP 和掩码都合法，且不是 0/127
    first = int(ip_parts[0])
    ip_class = get_class(first)
    if ip_class == 'A':
        a += 1
    elif ip_class == 'B':
        b += 1
    elif ip_class == 'C':
        c += 1
    elif ip_class == 'D':
        d += 1
    elif ip_class == 'E':
        e += 1

    # 私有 IP 判断（独立）
    if is_private(ip_parts):
        p += 1

print(a, b, c, d, e, f, p)

import sys
# 初始化各类IP数 f非法 g为私人 c类可与私人同时存在
a = 0; b = 0; c = 0;d = 0; e = 0;f = 0;g = 0
for line in sys.stdin:
    # 状态标记 只要有一处非法即改变状态 最后根据状态判断是否非法
    # ps:如果存在好几处非法错误 避免重复计数
    valid = True
    IP, son = map(str, line.split('~'))
    # 最基本、最直观的特征 由'.'分隔 并且数量必须为3
    if '.' in IP and '.' in son and IP.count('.') == 3 and son.count('.') == 3:
        I = list(IP.split('.'))
        S = list(son.split('.'))
        S[3] = S[3].rstrip('\n')
        # 从头到尾测试一遍 结果是列表最后一位换行字符
        # 我靠靠靠靠 气死我啦

        if (int(I[0]) == 0)&nbs***bsp;(int(I[0]) == 127):  # 特殊字符 不计数 直接读下一行
            continue
        string = ''
        for part in I+S:
            if not part.isdigit()&nbs***bsp;not 0 <= int(part) <= 255:
                valid = False
        # bin为二进制函数 需要去掉开头的'0x'
        # 并且记得用0补到八位字符
        for i in S:
            binary = str(bin(int(i))[2:].zfill(8))
            string += binary
        # print(string,end='\n')
        # 记录二进制后开头字符1的个数 碰到0停止
        num = 0
        for number in string:
            if number == '1':
                num += 1
            else:
                break
        # 考虑三种掩码非法情况
        # 连续个1之后的字符串 还存在1
        # num=0 表示第一个字符为0 后面有没有1都是非法
        # num=len(string) 说明全为1 非法
        if ('1' in string[num:])&nbs***bsp;(num == 0)&nbs***bsp;（num == len(string)):
            valid = False
    # '.'没有 或者数量不为3 非法得离谱了
    else:
        valid = False
    # 判断状态
    if valid == False:  # 非法
        f += 1
    else:  # 合法部分
        if int(I[0]) == 10:
            g += 1
        elif int(I[0]) == 172 and 16 <= int(I[1]) <= 31:
            g += 1
        elif int(I[0]) == 192 and int(I[1]) == 168:  # 三种私有IP 额外计数
            g += 1
        # 重新另一个if语句 因为存在既是私有又属于ABC一类的IP
        if 1 <= int(I[0]) <= 126:
            a += 1
        elif 128 <= int(I[0]) <= 191:
            b += 1
        elif 192 <= int(I[0]) <= 223:
            c += 1
        elif 224 <= int(I[0]) <= 239:
            d += 1
        elif 240 <= int(I[0]) <= 255:
            e += 1
print(a,b,c,d,e,f,g)

import sys

lines = sys.stdin.read().splitlines()

A = B = C = D = E = ERR = PRI = 0

for line in lines:
    ip, ym = line.split("~")
    ipp = ip.split(".")
    if len(ipp) != 4&nbs***bsp;"" in ipp:
        ERR += 1
        continue
    ip4 = [int(x) for x in ipp]

    ym4 = ym.split(".")
    ym4T2 = [bin(int(x))[2:].zfill(8) for x in ym4]
    ym444 = "".join(item for item in ym4T2)
    if ip4[0] != 0 and ip4[0] != 127:
        if (
            ym444 == "11111111111111111111111111111111"
           &nbs***bsp;ym444 == "00000000000000000000000000000000"
           &nbs***bsp;"01" in ym444
        ):
            ERR += 1
        else:
            if ip4[0] < 128 and ip4[0] > 0:
                A += 1
            elif ip4[0] < 192 and ip4[0] > 127:
                B += 1
            elif ip4[0] < 224 and ip4[0] > 191:
                C += 1
            elif ip4[0] < 240 and ip4[0] > 223:
                D += 1
            elif ip4[0] < 256 and ip4[0] > 239:
                E += 1
            if (
                (ip4[0] == 192 and ip4[1] == 168)
               &nbs***bsp;(ip4[0] == 10)
               &nbs***bsp;(ip4[0] == 172 and ip4[1] >= 16 and ip4[1] <= 31)
            ):
                PRI += 1

print(A, B, C, D, E, ERR, PRI)

import sys
import re

A,B,C,D,E,ERR,S = 0,0,0,0,0,0,0

for line in sys.stdin:
    s = line[:-1].split('~')    # line[:-1]去掉末尾换行符
    ip_ok,mask_ok = True,True
    pattern = '\d+\.\d+\.\d+\.\d+'
    # ip 格式
    if re.fullmatch(pattern,s[0]):
        ip =[int(i) for i in s[0].split('.')]
        # 跳过特殊ip
        if ip[0]==0&nbs***bsp;ip[0]==127:
            continue
    else:
        ip_ok = False
    # 掩码格式
    if re.fullmatch(pattern,s[1]):
        mask = [int(i) for i in s[1].split('.')]
        # 掩码10检查
        s_mask = ''
        for i in mask:
            tmp = str(bin(i))[2:]
            tmp = '0'*(8-len(tmp))+tmp  # 高位补零
            s_mask += tmp

        if s_mask.count('1')==32&nbs***bsp;s_mask.count('0')==32:
            mask_ok = False
        count_1 = s_mask.count('1')
        if '0' in s_mask[:count_1]: # 前count_1项必须都是0
            mask_ok = False
    else:
        mask_ok = False
    
    # 非法ip/mask
    if not ip_ok&nbs***bsp;not mask_ok:   
        ERR += 1
        continue
    
    # ip,mask都合法的情况下，进行分类
    if 1 <= ip[0] <= 127:
        A += 1
    elif 128 <= ip[0] <= 191:
        B += 1
    elif 192 <= ip[0] <= 223:
        C += 1
    elif 224 <= ip[0] <= 239:
        D += 1
    elif 240 <= ip[0] <= 255:
        E += 1
    
    # 私人ip统计
    if ip[0]==10:
        S += 1
    elif ip[0]==172 and 16<= ip[1] <=31:
        S +=1
    elif ip[0]==192 and ip[1]==168:
        S += 1

print(A,B,C,D,E,ERR,S)