题解 | #数据分类处理#

#include<math.h>
struct node                           //整个链表吧，思路是将每个 R 值的输出用链表连起来，最后一起计数并输出。不需要输出的就设为-1便于过滤
{
    int data;
    struct node *next;
};
 struct node *compare(int I[], int length, int r);     //判断数组 I 是否包含 r ，并生成所需数组
 void sort(int R[], int length);                               //最简单的直接插入排序          话说这题的重点真的是排序么？瞎标的吧
 
 int main()                                                           //以链表的形式把结果都连起来，最后计数并输出
 {
     int num1, num2;
     while(scanf("%d", &num1)!=EOF)
     {
         int I[num1];
         for(int a=0; a<num1; a++)                         //这里使用了变量来定义数组长度，只有c99能用。不是c99的话请自行用动态内存申请创建数组
         {
             scanf("%d", &I[a]);
         }
         scanf("%d", &num2);
         int R[num2];
         for(int a=0; a<num2; a++)
         {
             scanf("%d", &R[a]);
         }
         sort(R, num2);
         struct node *head;
         struct node *p, *q;
         head=(struct node *)malloc(sizeof(struct node));
         head->data=-1;
         head->next=NULL;
         q=head;
         int count=0;
         for(int a=0; a<num2; a++)
         {
             if(R[a]>-1)                                                        //因为 R 用的线性存储的数组，删改还挺麻烦的。所以排序后重复的 R 值直接置为-1过滤掉
             {
                 q->next=compare(I, num1, R[a]);
                 q=q->next;
                 while(q->next)
                 {
                    if(q->data>-1)    count++;
                    q=q->next;
                 }
                 if(q->data>-1)    count++;
             }
         }
         head->data=count;
         while(head)
         {
             if(head->data>-1)    printf("%d ", head->data);              //同样，对于未找到包含的数值 r 值，即在compare函数中被设为-1的值进行过滤
             head=head->next;
         }
         free(head);
         printf("\n");
     }
     return 0;
     }



struct node *compare(int I[], int length, int r)
{
    struct node *head;
    head=(struct node *)malloc(sizeof(struct node));
    head->data=r;
    struct node *p;
    p=(struct node *)malloc(sizeof(struct node));
    p->next=NULL;
    head->next=p;
    int digitR=digit(r);
    int count=0;
    for(int i=0; i<length; i++)
    {
        if(I[i]<r)    continue;
        int sign=0;
        int x=I[i];
        for(int j=digitR; j<=digitI; j++)
        {
            int test;
            test=x%((int)pow(10,digitR));
            if(test==r)
            {
                sign=1;
                break;
            }
            x/=10;
        }
        if(sign==1)
        {
            struct node *q;
            q=(struct node *)malloc(sizeof(struct node));
            q->data=i;
            struct node *k;
            k=(struct node *)malloc(sizeof(struct node));
            k->data=I[i];
            k->next=NULL;
            q->next=k;
            p->next=q;
            p=q->next;
            count++;
        }
    }
    head->next->data=count;
    if(count==0)
    {
        head->data=-1;                                //对于未找到包含值的 r 值，data值设为-1用于过滤。同时切掉后续链表，便于主程序最后计数和输出时跳过
        head->next=NULL;
    }
    return head;
}

int digit(int num)
{
    int digit=1;
    while(num>9)
    {
        num/=10;
        digit++;
    }
    return digit;
}




 void sort(int R[], int length)
 {
     int i;
     int t;
     int sign;
     for(i=0; i<length; i++)
     {
         for(int j=0; j<(i+1); j++)
         {
             if(R[i]<=R[j])
             {
                 t=R[i];
                 for(int k=i; k>(j-1); k--)
                 {
                     R[k]=R[k-1];
                 }
                 R[j]=t;
                 break;
             }    
         }
     }
     for(i=0; i<(length-1); i++)
     {
         if(R[i]==R[i+1])
         {
             R[i+1]=-1;
             i++;
         }
     }
 }