一道oj题的思路

nameisnothing

这道题我样例过了，但是答案错误。我不知道会不会是我思路有问题。
题目描述
互联网中存在许多的不和谐词汇，在我们浏览互联网的时候，搜索引擎经常会出现提示信息“根据相关法律法规和政策，部分搜索结果未予显示”。小王同学也想制作一个自己的屏蔽词库，这样他就可以将自己不喜欢的词汇从文件中换成别的字符了。屏蔽词库是一个ASCII码文件，这个文件中只含有单词，每个单词占一行，每个单词中只可能有大小写字母与空格。题目中和谐词库的文件名为dict.dic。（屏蔽词库中每个词汇长度小于10，屏蔽词汇个数不超过10.）
你的任务是将输入中的所有和谐词库中的词语全部替换成“!@#$%^&*”（按住键盘shift和数字1至8），然后输出。这里要注意，如果一个词语中包含屏蔽词汇，那么只将屏蔽词汇替换，例如“hehasAAA”被处理后将得到“he!@#$%^&*AAA”，注意屏蔽词汇区分大小写，即aaa与AAA是两个不同的单词，为了使问题简化，屏蔽词汇中不会出现互相包含的情况，如“xabcx”与“abc”不会同时出现在同一个屏蔽词库中。由于小王同学很不擅长文件操作，所以他希望你能帮他制作这个屏蔽词汇程序。
输入
若干长度小于100的字符串。
输出
添加屏蔽词后的结果。
样例输入

1. [/code]
   
2. The night falls gently. And you are not here. I missing you more and more and I start getting worried as
   
3. I stare at the door just waiting for you to surprise me with your arrival at any moment.
   
4. Sweet delusion... you are so far away right now that all I can ask for is that time moves faster...
   
5. 
   
6. 样例输出
   
7. 如果屏蔽词库如下：
   
8. is
   
9. good
   
10. are
    
11. the
    
12. ha ha
    
13. some
    
14. get
    
15. has
    
16. more
    
17. bad
    
18. 则输出：
    
19. 
    
20. The night falls gently. And you !@#$%^&* not here. I m!@#$%^&*sing you !@#$%^&* and !@#$%^&* and I start !@#$%^&*ting worried as
    
21. I st!@#$%^&* at !@#$%^&* door just waiting for you to surpr!@#$%^&*e me with your arrival at any moment.
    
22. Sweet delusion... you !@#$%^&* so far away right now that all I can ask for !@#$%^&* that time moves faster...
    
23. 
    
24. [code]#include<stdio.h>
    
25. #include<string.h>
    
26. void check(char *s,char *a);//屏蔽信息
    
27. void print(char *a);//打印
    
28. int main(void)
    
29. {
    
30.         char a[110];
    
31.         while(gets(a))//循环输入
    
32.         {
    
33.             FILE *fp=fopen("dict.dic","r");
    
34.             while(!feof(fp))
    
35.            {
    
36.                         char c=getc(fp);
    
37.                         char s[11]={'0'};
    
38.                         int i=0;
    
39.                         while(c!='\n'&&c!=EOF)
    
40.                        {
    
41.                                    s[i]=c;
    
42.                                    i++;  
    
43.                                    c=getc(fp);//读取屏蔽词
    
44.                     }
    
45.                                check(s,a);
    
46.             }
    
47.         print(a);
    
48.                 printf("\n");       
    
49.         }
    
50.         return 0;
    
51. }
    
52. void check(char *s,char *a)
    
53. {
    
54.         int x=strlen(s);
    
55.         int y=strlen(a);
    
56.         int i,j=0,k=0,r=0;
    
57.         for(i=0;i<y;i++)
    
58.         {
    
59.                 if(a[i]==s[j])
    
60.                 {
    
61.                         k=i;
    
62.                         r=j;
    
63.                         while(k<y&&r<x&&a[k]==s[r])
    
64.                          k++,r++;//判断是否一致       
    
65.                 }
    
66.                 if(r==x&&x!=1)
    
67.                 {
    
68.                         a[k-1]='!';
    
69.                         for(int t=2;t<=x;t++)
    
70.                             a[k-t]='?';//屏蔽信息
    
71.                 }
    
72.                 else if(r==x&&x==1)
    
73.                     a[k-1]='!'; //屏蔽信息                            
    
74.         }
    
75.         return;
    
76. }
    
77. void print(char *a)
    
78. {
    
79.         int x=strlen(a);
    
80.         for(int i=0;i<x;)
    
81.         {
    
82.           if(a[i]!='?'&&a[i]!='!')
    
83.            {
    
84.             printf("%c",a[i]);
    
85.                 i++;                 
    
86.            }
    
87.           else if(a[i]=='?')
    
88.            {
    
89.             printf("!@#$%^&*");//打印屏蔽字符
    
90.             while(a[i]=='?')
    
91.                     i++;     
    
92.                 }       
    
93.            else
    
94.            {
    
95.             if(a[i-1]=='?'&&i>0)
    
96.                     i++;
    
97.                 else
    
98.                     printf("!@#$%^&*"),i++;        //单个字母打印                
    
99.            }       
    
100.         }
     
101.            return;
     
102. }

复制代码

人造人

你为什么不自己做？

人造人

好吧，你在自己写了

人造人

给你个思路，先把dict.dic文件中的所有单词都读取出来，保存到数组
然后对字符串进行扫描，匹配到的单词进行替换，不匹配就输出

nameisnothing

人造人 发表于 2020-3-25 16:42
给你个思路，先把dict.dic文件中的所有单词都读取出来，保存到数组
然后对字符串进行扫描，匹配到的单词进 ...

我不就是这么做的吗

Cool_Breeze

strcmp 比较字符串
将关键字符串和输入字符串比较(可以百度在一串字符中搜索指定指定字符串)。如果有记录位置，替换。我想应该可以的！

nameisnothing

我现在想知道我这段代码具体错在哪里，如果错了，应该怎么改，毕竟每个人思路不同，太多了，不可能一个思路写一次。

Cool_Breeze

给你个思路，你看看行不行！

1. #include <stdio.h>
   
2. #include <stddef.h>
   
3. #include <string.h>
   
4. 
   
5. int findstr(char *s,char *f,char *c);
   
6. int main(void)
   
7. {
   
8.         char arr[1024]="dsafdsafdsafdasliowjhfo afhafdhfsdjadbs vbdkhdio;oagfeafselfopwfh";
   
9.         char temp[10]="af";
   
10.         char ch[10]="????????";
    
11.         findstr(arr,temp,ch);
    
12.     return 0;
    
13. }
    
14. //采用类似字符串拼接方式
    
15. int findstr(char *s,char *f,char *c)
    
16. {
    
17.         //获取字符串长度
    
18.         size_t s_len=strlen(s);
    
19.         size_t f_len=strlen(f);
    
20.         size_t c_len=strlen(c);
    
21.        
    
22.         if (s_len < f_len ) return -1;//如果输入字符串比约束字符串短就退出
    
23.         register int i=0,j=0;
    
24.         for (;i<s_len-f_len;i++)
    
25.                 if ( ! strncmp(s+i,f,f_len) )
    
26.                 {
    
27.                         *(s+i)='\0';
    
28.                         printf("%s%s",s+j,c);
    
29.                         j=i+f_len;
    
30.                         i=i+f_len-1;
    
31.                 }
    
32.         printf("%s",s+j);//打印剩余字符串或者原字符串；
    
33.         return 0;
    
34. }

复制代码

1. ds????????ds????????ds????????dasliowjhfo ????????h????????dhfsdjadbs vbdkhdio;oagfe????????selfopwfh
   
2. --------------------------------
   
3. Process exited after 0.01573 seconds with return value 0
   
4. 请按任意键继续. . .

复制代码

nameisnothing

Cool_Breeze 发表于 2020-3-25 18:34
给你个思路，你看看行不行！

谢谢兄弟，但我其实还是想弄懂自己代码错在哪里。

shimmermao

Cool_Breeze 发表于 2020-3-25 17:12
strcmp 比较字符串
将关键字符串和输入字符串比较(可以百度在一串字符中搜索指定指定字符串)。如果有记录 ...

可不太行，还是得一个个字母循环，因为观察事例可以发现在在单词中间也可能存在敏感词

Cool_Breeze

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <stddef.h>
   
4. #include <string.h>
   
5. 
   
6. FILE* filepointer(const char *file,const char *mode);
   
7. void insert_str(char* str,char* flag,size_t sl,size_t fn);
   
8. void replace_gtr_str(char* str,char* flag,size_t sl,size_t fl);
   
9. void replace_lss_str(char* str,char* flag,size_t subl,size_t fl);
   
10. void replace_equ_str(char* str,char* flag,size_t fl);
    
11. 
    
12. //字符串大小
    
13. #define Max 1024
    
14. 
    
15. int main(int argc,char **argv)
    
16. {
    
17.         FILE* fp=filepointer("test.txt","rb");
    
18.         FILE* fpo=filepointer("result.txt","wb");        
    
19.         static char str[Max];
    
20.         static char substr[Max]={"888"};//需要替换的字符串
    
21.         static char flag[Max]={"<A>"};//替换后的字符串
    
22.         char *p=str;
    
23.         while (fgets(str,Max,fp))
    
24.         {
    
25.                 p=str;
    
26.                 for (;;)
    
27.                 {
    
28.                         p=strstr(p,substr);
    
29.                         if (p == NULL) break;
    
30.                         if (strlen(substr) < strlen(flag)) replace_lss_str(p,flag,strlen(substr),strlen(flag));
    
31.                         else if (strlen(substr) > strlen(flag)) replace_gtr_str(p,flag,strlen(substr),strlen(flag));
    
32.                         else if (strlen(substr) == strlen(flag)) replace_equ_str(p,flag,strlen(flag));
    
33.                 }
    
34.                 fprintf(fpo,"%s",str);
    
35.         }
    
36.         fclose(fp);
    
37.         fclose(fpo);
    
38.     return 0;
    
39. }
    
40. 
    
41. FILE* filepointer(const char *file,const char *mode)
    
42. {
    
43.         FILE *fp;
    
44.         if (!(fp = fopen(file,mode)))
    
45.         {
    
46.                 printf("open fail! [%s]:%s\n",file,strerror(errno));
    
47.                 exit(EXIT_FAILURE);
    
48.         }
    
49.         return fp;
    
50. }
    
51. /*
    
52.         在字符串开始插入指定字符串
    
53.         str  原字符串的起点
    
54.         flag 指定字符串
    
55.         sl   原字符串长度
    
56.         fl   指定字符串长度
    
57. */
    
58. void insert_str(char* str,char* flag,size_t sl,size_t fl)
    
59. {
    
60.         memmove(str+fl,str,sl+1);//+1存放结束符'\0'
    
61.         memmove(str,flag,fl);
    
62. }
    
63. /*
    
64.         被替换字符串长度大于替换字符字符串长度
    
65.         explanation:
    
66.         str=abcd,flag=abc
    
67.         
    
68.         str  原字符串的起点
    
69.         flag 替换的字符串
    
70.         sl   被替换字符长度
    
71.         fl   替换字符串长度
    
72. */
    
73. void replace_gtr_str(char* str,char* flag,size_t sl,size_t fl)
    
74. {
    
75.         memmove(str+fl,str+sl,sl+1);
    
76.         memmove(str,flag,fl);
    
77. }
    
78. /*
    
79.         被替换字符长度小于替换字符串长度
    
80.         删除被替换字符串
    
81.         explanation:
    
82.         str=abc,flag=abcd
    
83.         
    
84.         str  原字符串的起点
    
85.         flag 替换的字符串
    
86.         subl 被替换字符长度
    
87.         fl   替换字符串长度
    
88. */
    
89. void replace_lss_str(char* str,char* flag,size_t subl,size_t fl)
    
90. {
    
91.         register size_t temp=strlen(str)-subl;//剩余字符串长度
    
92.         memmove(str+fl,str+subl,temp+1);
    
93.         memmove(str,flag,fl);
    
94. }
    
95. /*
    
96.         被替换字符串与指定字符串相等
    
97.         explanation:
    
98.         str=abc,flag=abc
    
99.         
    
100.         str  原字符串的起点
     
101.         flag 替换的字符串
     
102.         fl   替换字符长度
     
103.          
     
104. */
     
105. void replace_equ_str(char* str,char* flag,size_t fl)
     
106. {
     
107.         memmove(str,flag,fl);
     
108. }

复制代码

luoruitao

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main()
{
        char huan[11];
        char *words[11];
        char pingbi[]={"!@#$%^&*"};
        int len,i=0,count,j,k,flag=0,o;
        int num[10];
        FILE *fp=fopen("dict.dic","r");
        while((fgets(huan,10,fp))!=NULL)
        {
                num[i]=strlen(huan);
                words[i]=(char *)malloc(len+1);
                strcpy(words[i],huan);
                i++;
        }
        count=i;                                                                        //用来记录有多少屏蔽单词
        if(count>1)
        {
                for(i=0;i<count-1;i++)
                {
                        num[i]--;
                        for(j=0;j<num[i];j++)
                        {
                                huan[j]=words[i][j];
                        }
                        huan[j]='\0';
                        strcpy(words[i],huan);                                //此处调整字符数组中再字母后有莫名其妙字符的影响并把回车去掉
                }
        }
        /*for(i=0;i<count;i++)
        {
                puts(words[i]);
                printf("%d\n",num[i]);       
        }*/
        i=0;
        char chuli[111];
        while((gets(chuli))!=NULL)                                        //处理输入的字符
        {
                while(chuli[i]!='\0')                                        //处理一串字符串中的每一个字符
                {
                        for(j=0;j<count&&flag==0;j++)                //对应每一个屏蔽词
                        {
                                for(k=0;k<num[j];k++)                         
                                {
                                        huan[k]=chuli[i+k];                        //提取和屏蔽词字符数一样的部分复制在huan字符数组里
                                }
                                huan[k]='\0';
                                if(strcmp(huan,words[j])==0)        //如果字符对应上，说明是相同的
                                {
                                        flag=1;
                                        printf("%s",pingbi);
                                        i+=num[j]-1;
                                }
                        }
                        if(flag==0)
                        putchar(chuli[i]);                                        //如果没有对应字符，直接输出
                        i++;
                        flag=0;
                }
                printf("\n");
                i=0;
        }
        return 0;
}
       
注：非ac码，只是提供一种思路，希望有大佬斧正

Cool_Breeze

去看看这个帖子字符串替换

Given2001

大概找到问题所在了
你的思路大概是检查原字符串，然后把找到的和谐词替换成 ！？？？ 的形式，这样做是不安全的，要是原文就存在感叹号和问号就会错误屏蔽。
具体看我的测试图