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

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
//本题有个学习点就是如何循环输入
//自测都可以过但是提交提示段错误

//IP地址检测
int legalIP(char* a)
{
    int i,j=1;
    int num[4]={0};
    num[0] =  atoi(&a[0]);
    for(i=0; i<=strlen(a); i++)
    {
        if(a[i] == '.')
        {
            if(a[i+1] >= '0' && a[i+1] <= '9')
           {
            num[j] = atoi(&a[i+1]);
            j++;
           }
        }
    }
        if(j == 4 && (num[0]>=1 && num[0]<=255) && (num[1]>=0 && num[0]<=255)  && (num[2]>=0 && num[0]<=255) && (num[3]>=0 && num[0]<=255))
        {
            return 1;
        }
        else {
            return 0;
        } 
}
//三位数掩码是否合法
int legalMask2(int a)
{
    int i=255;
    while(i >= 0)
    {
        if(a == (i & 255))
        {           
            return 1;
        }
        i = i << 1;
    }
    return 0;
}
//掩码是否合法
int legalMask(char* a)
{
    int i,j=1;
    int num[4]={0};
    num[0] = atoi(&a[0]);
    for(i=0; i<=strlen(a); i++)
    {
        if(a[i] == '.')
        {
            if(a[i+1] >= '0' && a[i+1] <= '9')
            {    
                num[j] = atoi(&a[i+1]);
                j++;
            }
        }
    }
    if(j == 4)
    {
        if(num[0] == 255)
        {
            if(num[1] == 255)
            {
                if(num[2] == 255)
                {
                    if(legalMask2(num[3]) && num[3] != 255)
                        return 1;
                    else
                        return 0;
                }
                else if(legalMask2(num[2]) && num[3] == 0)
                {
                    return 1;
                }
                else {
                    return 0;
                }
            }
            else if(legalMask2(num[1]) && num[2] == 0 && num[3] == 0)
            {
                return 1;
            }
            else {
                return 0;
            }
               
        }
        else if(legalMask2(num[0]) && num[1] == 0 && num[2] == 0 && num[3] == 0 && num[0] != 0)
        {
            return 1;
        }
        else {
            return 0;
        }

    }
    else {
        return 0;
    }
}

int main() {
    char input[1000][40]={0};
    char IP[1000][20]={0},Mask[1000][20]={0};
    int i=0,j=0;
    int num[7]={0};
    //直接用for循环输入不进来
    while(scanf("%s",&input[i][0]) != EOF)
    {
        for(j=0; j<=40; j++)
        {
            if(input[i][j] == '~')
            {
                input[i][j] = '\0';
                strcpy(&IP[i][0], &input[i][0]);
                strcpy(&Mask[i][0], &input[i][j+1]);
                break;
            }
        }
        if(legalIP(&IP[i][0]) && legalMask(&Mask[i][0]))
        {
            if(atoi(&IP[i][0]) >=1 && atoi(&IP[i][0]) <=126)
            num[0] += 1;
            else if(atoi(&IP[i][0]) >=128 && atoi(&IP[i][0]) <=191)
            num[1] += 1;
            else if(atoi(&IP[i][0]) >=192 && atoi(&IP[i][0]) <=223)
            num[2] += 1;
            else if(atoi(&IP[i][0]) >=224 && atoi(&IP[i][0]) <=239)
            num[3] += 1;
            else if(atoi(&IP[i][0]) >=240 && atoi(&IP[i][0]) <=255)
            num[4] += 1;

            if(atoi(&IP[i][0]) == 10)
            num[6] += 1;
            if(atoi(&IP[i][0]) == 172 && (atoi(&IP[i][4]) >=16 && atoi(&IP[i][4]) <=31))
            num[6] += 1;
            if(atoi(&IP[i][0]) == 192 && atoi(&IP[i][4]) == 168)
            num[6] += 1;
        }
        else if(atoi(&IP[i][0]) == 0 || atoi(&IP[i][0]) == 127)
        i = i;
        else {
            num[5] += 1;
        }
    i++;
    }
    printf("%d %d %d %d %d %d %d",num[0],num[1],num[2],num[3],num[4],num[5],num[6]);
    return 0;
}

#include <stdio.h>
//将输入的字符串转换成整型存入数组中，方便判断
void change(char* str,int arr[])
{
    char* start=str;
    char* end=str;
    int i=0;
    int j =0;
    for(i=0;i<32;i++)
    {
        if(str[i]=='.'||str[i]=='\0'||str[i]=='~')
        {
            if(start==end)//点后接点如19..0.
            {
                arr[0]=1000;
                break;
            }
            for(;start<end;start++)
            {
                arr[j]=arr[j]*10+(int)(*start-'0');
            }
            //printf("%d ",arr[j]);
            start++;
            j++;
        }
        if(str[i]=='\0')
            break;
        end++;
    }
}
//掩码判断
int netmask(int arr[])
{
    unsigned int integerMask = 0;
    //将掩码变成无符号整数
    for (int i = 0; i < 4; i++) 
    {
        integerMask += arr[i+4] << (24 - 8 * i);
        //printf("%u\n",integerMask);
    }
    
    int networkBits = 0;
    int hostBits = 0;
    int isHostBitsStarted = 0;

    for (int i = 31; i >= 0; i--) 
    {
        if ((integerMask>> i) & 1) 
        {
            if (isHostBitsStarted) //有0后又出现1即为错误掩码
            {
                return 0; // 掩码无效：主机位中有1
            }
            networkBits++;
        } 
        else 
        {
            isHostBitsStarted = 1;//开始有0，
            hostBits++;
        }
    }
    if(networkBits ==32||hostBits ==32)//全零或者全1
    {
        return 0;
    }
    return 1;
}
//类型判断
void classfication(int arr[],int output[])
{
    int ret =netmask(arr);
    //printf("%d\n",ret);
    //五类
    if(arr[0]>=1&&arr[0]<=126&&ret ==1)
    {
        output[0]++;
    }
    else if(arr[0]>=128&&arr[0]<=191&&ret ==1)
    {
        output[1]++;    
    }
    else if(arr[0]>=192&&arr[0]<=223&&ret ==1)
    {
        output[2]++;
    }
    else if(arr[0]>=224&&arr[0]<=239&&ret ==1)
    {
        output[3]++;
    }
    else if(arr[0]>=240&&arr[0]<=255&&ret ==1)
    {
        output[4]++;
    }
    else if(arr[0]==0||arr[0]==127);
    else
    {
        output[5]++;
    }
    //私网ip
    if(arr[0]==10&& ret ==1)
    {
        output[6]++;
    }
    else if(arr[0]==172&&arr[1]>=16&&arr[1]<=31&&ret ==1)
    {
        output[6]++;
    }
    else if(arr[0]==192&&arr[1]==168&&ret ==1)
    {
        output[6]++;
    }
}
//输出
void print(int output[])
{
    //printf("\n");
    for(int i=0;i<7;i++)
    {
        printf("%d ",output[i]);
    }
}

int main() {
    char ip[32]={0};
    int output[7]={0}; 
    while(scanf("%s",ip)!=EOF)
    {
        int arr[8]={0};
        change(ip,arr);
        classfication(arr,output);
    }
        print(output);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* 描述
请解析IP地址和对应的掩码，进行分类识别。要求按照A/B/C/D/E类地址归类，不合法的地址和掩码单独归类。 */



int main()
{
    /* 思路
        输入一行后进行判断统计,然后输入下一行
    */

    char astring[32] = {0};
    int output[7] = {0};

    int length=0;
    long hide;
    int i,l,error=0,n,m=0;
    int number[8];

    /* 循环输入，输入后直接对数据处理，统计 */
    while(fgets(astring,32,stdin)!=NULL)
    {
        length=strlen(astring);
        for(i=0;i<8;i++)
            number[i]=0;
        l=0;
        m=0;
        error = 0;//参数清零

        if(astring[length-1]=='\n'){
            astring[length-1]=0;
            length--;
        }
        
        /* 将ip~掩码字符串拆分放进整数数组 */

        for(n=0;n<8;n++)
        {
            while(astring[l]!='.'&&astring[l]!='~'&&astring[l]!=0)
            {
                if(astring[l]<'0'||astring[l]>'9')
                    error = 1;//ip是否有误
                l++;
            }

            switch(l-m){
                case 3:
                    number[n] += (astring[l-3]-'0')*100;
                case 2:
                    number[n] += (astring[l-2]-'0')*10;
                case 1:
                    number[n] += astring[l-1]-'0';
                    if(number[n]>255)
                        error = 1;//ip是否有误
                    break;
                default:
                    error = 1;//ip是否有误
            }
            l++;
            m=l;
            
        }
        /* 判断子网掩码是否正确 */
        for(i=0;i<4;i++)
        {
            for(n=0;n<7;n++)
            {
                if((number[i+4]&(3<<n))==(1<<n))
                   error = 1;
            }
        }
        
        if ( (!(number[4] & 1) && (number[5] & (1 << 7))) ||
                (!(number[5] & 1) && (number[6] & (1 << 7))) ||
                (!(number[6] & 1) && (number[7] & (1 << 7)))||
                (number[4]==255&&number[5]==255&&number[6]==255&&number[7]==255)||
                (number[4]==0&&number[5]==0&&number[6]==0&&number[7]==0))
                error = 1;
        /* 综合处理判断ip或子网掩码是否正确-注意127和0不考虑 */
        if(error&&number[0]!=127&&number[0]!=0)
        {
            
            output[5]++;
        }
        else
        {
        /* 统计ABCDE和私有ip */
            if(number[0]>=1&&number[0]<=126)
            {
                output[0]++;//a
            }
            else if(number[0]>=128&&number[0]<=191)
            {
                output[1]++;//b
            }
            else if(number[0]>=192&&number[0]<=223)
            {
                output[2]++;//c
            }
            else if(number[0]>=224&&number[0]<=239)
            {
                output[3]++;//d
            }
            else if(number[0]>=240&&number[0]<=255)
            {
                output[4]++;//e
            }

            if((number[0]==10)||
               (number[0]==172&&number[1]>=16&&number[1]<=31)||
               (number[0]==192&&number[1]==168) )
                output[6]++;

        }

    }
    /* 输出 */
    for(i=0;i<6;i++)
            printf("%d ",output[i]);
        printf("%d",output[6]);


}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


void scan_replace(char *ip, char *pos[]){
    int i = 0;
    int j = 1;
    pos[0] = ip;
    while (ip[i] != '\0' && j < 4){
        if (ip[i++] != '.')
            continue;
        pos[j++] = &ip[i];
        ip[i - 1] = '\0';
    }
}

int check_mask(long long mask){
    int last_digit = mask & ~(mask - 1);
    if (last_digit == 1)
        mask -= 1;
    mask /= last_digit;
    while (mask > 0){
        if (mask % 2 == 0)
            return 0;
        mask >>= 1;
    }
    return 1;
}

// 0~4: A/B/C/D/E, 5: Error, 6~8: A/B/C+Private, -1: 127.*.*.*
int classify(char *ip, char *mask){
    char *ip_groups[4] = {0};
    char *mask_group[4] = {0};
    scan_replace(ip, ip_groups);
    scan_replace(mask, mask_group);
    for (int i = 0; i < 4; i++){
        if (ip_groups[i][0] == '\0' || mask_group[i][0] == '\0')
            return 5;
    }
    long long mask_int = 0;
    for (int i = 0; i < 4; i++){
        mask_int <<= 8;
        int num = atoi(mask_group[i]);
        if (num < 0 || 255 < num)
            return 5;
        mask_int |= num;
    }
    if (mask_int == 0 || mask_int == 0xFFFFFFFF || check_mask(mask_int) == 0)
        return 5;
    long long ip_int = 0;
    for (int i = 0; i < 4; i++){
        int num = atoi(ip_groups[i]);
        if (num < 0 || 255 < num)
            return -5;
        ip_int *= 1000;
        ip_int += num;
    }

    if (0 <= ip_int && ip_int <= 255255255)
        return -1;
    if (127000000000 <= ip_int && ip_int <= 127255255255)
        return -1;

    int ret;
    // A
    if (1000000000 <= ip_int && ip_int <= 126255255255){
        ret = 0;
        if (10000000000 <= ip_int && ip_int <= 10255255255)
            ret += 6;
    // B
    } else if (128000000000 <= ip_int && ip_int <= 191255255255){
        ret = 1;
        if (172016000000 <= ip_int && ip_int <= 172031255255)
            ret += 6;
    // C
    } else if (192000000000 <= ip_int && ip_int <= 223255255255){
        ret = 2;
        if (192168000000 <= ip_int && ip_int <= 192168255255)
            ret += 6;
    // D
    } else if (224000000000 <= ip_int && ip_int <= 239255255255){
        ret = 3;
    // E
    } else if (240000000000 <= ip_int && ip_int <= 255255255255){
        ret = 4;
    } else
        ret = 5;
    return ret;
}

int main(void){
    int i = 0;
    char ch;
    char line[50] = {0};
    char *ip = line, *mask;
    int nums[7] = {0};
    while (scanf("%c", &ch) != EOF){
        if (ch == '\r' || ch == '\n'){
            int which = classify(ip, mask);
            if (which != -1)
                nums[which]++;
            if (which > 6){
                nums[6]++;
                nums[which - 6]++;
            }
            i = 0;
            memset((void*)line, '\0', 50);
            continue;
        }
        line[i++] = ch;
        if (ch == '~'){
            line[i - 1] = '\0';
            mask = &line[i];
        }
    }
    for (int i = 0; i < 7; i++)
        printf("%d ", nums[i]);
    return 0;
}

#include <stdio.h>

int main() {
    int ip[4], mk[4];       //IP地址、子网掩码
    int addrType[7] = {};   //地址类型
    int mask, typeId;       //掩码值、类型号
    int endAddr[] =         //类型尾地址
    {126, 191, 223, 239, 255};

    while (scanf("%d.%d.%d.%d~%d.%d.%d.%d", //读取IP地址和子网掩码
                 ip, ip + 1, ip + 2, ip + 3,
                 mk, mk + 1, mk + 2, mk + 3) == 8) {
        if (ip[0] == 0 || ip[0] == 127) //若非指定IP类型
            continue;
        //合并子网掩码为掩码值
        mask = (mk[0] << 24) + (mk[1] << 16) + (mk[2] << 8) + mk[3];
        if (((~mask + 1) & ~mask) || !~mask) {  //若掩码非连续1后0
            addrType[5]++;  //错误IP或掩码+1
            continue;
        }
        if (ip[0] == 10 || (ip[0] == 192 && ip[1] == 168) ||
                (ip[0] == 172 && ip[1] > 15 && ip[1] < 32)) //若为私有地址
            addrType[6]++;  //私有IP类型+1
        for (typeId = 0; ip[0] > endAddr[typeId]; typeId++); //遍历查找匹配类型
        addrType[typeId]++; //对应IP类型+1
    }
    for (typeId = 0; typeId < 7; typeId++)  //遍历地址类型
        printf("%d ", addrType[typeId]);    //打印IP类型数
}

#include <stdio.h>

typedef struct ip{
    int A;
    int B;
    int C;
    int D;
    int E;
    int error;
    int privacy;
}IP ;

int main() {
    char str[100] = {};
    IP ipv4 = {0};
    int ip[4] = {0};
    int mask[4] = {0};

    while (scanf("%s", str) != EOF) { // 注意 while 处理多个 case
        int ip_num = sscanf(str, "%d.%d.%d.%d~%d.%d.%d.%d", &ip[0],&ip[1],&ip[2],&ip[3],\
        &mask[0],&mask[1],&mask[2],&mask[3]);
    
        if(ip[0] == 0 || ip[0] == 127) //不属于任何一类，计数时忽略
            continue; 
        
        //IP地址或子网掩码输入格式错误
        if(ip_num != 8)   
         {
            ipv4.error++;
            continue;
         } 
        
        //判断子网掩码合法性
        if((mask[0] == 0 && mask[1] == 0 && mask[2] == 1 && mask[3] == 0)\
            || (mask[0] == 255 && mask[1] == 255 && mask[2] == 255 && mask[3] == 255))
        {
            ipv4.error++;
            continue;
        }
        int mask32 = 0;
        for(int i=3; i>=0; i--)
        {
            mask32 += mask[i] << 8*(3-i);   //将子网掩码合成32位整数
        }
        mask32 = ~mask32 + 1;   //取反为000…00111…1，然后再加1为00…01000…0，此时为2^n，如果满足就为合法掩码。
        if((mask32 & (mask32-1)) != 0)
        {
            ipv4.error++;
            continue;
        }

        //对正确IP地址分类
        if(ip[0] >= 1 && ip[0] <= 126)
        {
            ipv4.A++;
        }
        else if(ip[0] >= 128 && ip[0] <= 191)
        {
            ipv4.B++;
        }
        else if(ip[0] >= 192 && ip[0] <= 223)
        {
            ipv4.C++;
        }
        else if(ip[0] >= 224 && ip[0] <= 239)
        {
            ipv4.D++;
        }
        else 
        {
            ipv4.E++;
        }

        //私网
        if((ip[0] == 10) || (ip[0] == 172 && ip[1] >= 16 &&ip[1] <= 31) || \
            (ip[0] == 192 && ip[1] == 168))
        {
            ipv4.privacy++;
        }
    }

    printf("%d %d %d %d %d %d %d", ipv4.A,ipv4.B,ipv4.C,ipv4.D,ipv4.E,ipv4.error,ipv4.privacy);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define    N    30
#define    M    1000
int main()
{
    char* str[M], arr[32];
    int i = -1, j, m, n, p, A = 0, B = 0, C = 0, D = 0, E = 0, err = 0, pri = 0, flag, flag1,flag2, cnt, temp[4],num[4];
    do
    {
        i++;
        str[i] = (char*)malloc(sizeof(char) * N);
        gets(str[i]);
    } while (*str[i] != '\0');
    j = i;
    for (i = 0; i < j; i++)
    {
        flag = 0;flag1=0;
        for (cnt = 0; cnt < 4; cnt++)
        {
            num[cnt] = 0;
        }
        if ((*str[i] == '0' && *(str[i] + 1) == '.') || (*str[i] == '1' && *(str[i] + 1) == '2'
            && *(str[i] + 2) == '7' && *(str[i] + 3) == '.'))
        {
            continue;
        }
        else
        {
            cnt = 0; m = 0;
            while (*(str[i] + m) != '~')
            {
                if (*(str[i] + m) == '.'&&*(str[i] + m + 1) != '.')
                {
                    cnt++;
                    m++;
                    continue;
                }
                else if(*(str[i] + m) == '.'&&*(str[i] + m + 1) == '.')
                {
                    num[0]=-1;
                    break;
                }
                num[cnt] *= 10;
                num[cnt] += *(str[i] + m) - '0';
                m++;
            }
            if ((num[0] >= 1 && num[0] <= 126) && (num[1] >= 0 && num[1] <= 255) &&
                (num[2] >= 0 && num[2] <= 255) && (num[3] >= 0 && num[3] <= 255))
            {
                flag = 1;
            }
            else if ((num[0] >= 128 && num[0] <= 191) && (num[1] >= 0 && num[1] <= 255) &&
                (num[2] >= 0 && num[2] <= 255) && (num[3] >= 0 && num[3] <= 255))
            {
                flag = 2;
            }
            else if ((num[0] >= 192 && num[0] <= 223) && (num[1] >= 0 && num[1] <= 255) &&
                (num[2] >= 0 && num[2] <= 255) && (num[3] >= 0 && num[3] <= 255))
            {
                flag = 3;
            }
            else if ((num[0] >= 224 && num[0] <= 239) && (num[1] >= 0 && num[1] <= 255) &&
                (num[2] >= 0 && num[2] <= 255) && (num[3] >= 0 && num[3] <= 255))
            {
                flag = 4;
            }
            else if ((num[0] >= 240 && num[0] <= 255) && (num[1] >= 0 && num[1] <= 255) &&
                (num[2] >= 0 && num[2] <= 255) && (num[3] >= 0 && num[3] <= 255))
            {
                flag = 5;
            }
            if ((num[0] == 10 && (num[1] >= 0 && num[1] <= 255) &&
                (num[2] >= 0 && num[2] <= 255) && (num[3] >= 0 && num[3] <= 255)) ||
                (num[0] == 172 && (num[1] >= 16 && num[1] <= 31) &&
                    (num[2] >= 0 && num[2] <= 255) && (num[3] >= 0 && num[3] <= 255)) ||
                (num[0] == 192 && num[1] == 168 &&
                    (num[2] >= 0 && num[2] <= 255) && (num[3] >= 0 && num[3] <= 255)))
            {
                flag1 = 1;
            }
            if (flag == 0&&flag1==0)
            {
                err++;
            }
            else
            {
                memset(arr, '0', 32);
                flag2 = 0;
                for (cnt = 0; cnt < 4; cnt++)
                {
                    temp[cnt] = 0;
                }
                m++;
                cnt = 0;
                while (*(str[i] + m) != '\0')
                {
                    if (*(str[i] + m) == '.'&&*(str[i] + m + 1) != '.')
                    {
                        cnt++;
                        m++;
                        continue;
                    }
                    else if (*(str[i] + m) == '.'&&*(str[i] + m + 1) == '.')
                    {
                        for(n=0;n<4;n++)
                        {
                            temp[n]=0;
                        }
                        break;
                    }
                    temp[cnt] *= 10;
                    temp[cnt] += *(str[i] + m) - '0';
                    m++;
                }
                if ((temp[0] == 0 && temp[1] == 0 && temp[2] == 0 && temp[3] == 0) ||
                    (temp[0] == 255 && temp[1] == 255 && temp[2] == 255 && temp[3] == 255))
                {
                    err++;
                }
                else
                {
                    for (cnt = 0; cnt < 4; cnt++)
                    {
                        p = 8 * (cnt + 1) - 1;
                        for (n = 0; n < 8; n++)
                        {
                            arr[p--] = temp[cnt] % 2 + '0';
                            temp[cnt] /= 2;
                        }
                    }
                    for (n = 0; n < 32; n++)
                    {
                        if (arr[n] == '0')
                        {
                            flag2 = 1;
                        }
                        else if (arr[n] == '1' && flag2 == 1)
                        {
                            err++;
                            break;
                        }
                    }
                    if (n == 32)
                    {
                        if(flag1==1)
                        {
                            pri++;
                        }
                        switch (flag)
                        {
                        case 1:
                            A++;
                            break;
                        case 2:
                            B++;
                            break;
                        case 3:
                            C++;
                            break;
                        case 4:
                            D++;
                            break;
                        case 5:
                            E++;
                            break;
                        }
                    }
                }
            }
        }
    }
    printf("%d %d %d %d %d %d %d\n", A, B, C, D, E, err, pri);
    return 0;
}

//写了很久终于写出来了，虽然很烂，菜鸡啊

第八组案例 实在是过不去了，感觉A类型就70个，我一个一个找的，找出七十个。