devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

PTA L1-064 估值一亿的AI核心代码(详解)

作者：Cpp五条 | 2024-03-21 00:50:28

赞

踩

l1-064 估值一亿的ai核心代码

前言:内容包括:题目,代码实现,大致思路,代码解读

题目:

以上图片来自新浪微博。

本题要求你实现一个稍微更值钱一点的 AI 英文问答程序，规则是：

  • 无论用户说什么，首先把对方说的话在一行中原样打印出来；
  • 消除原文中多余空格：把相邻单词间的多个空格换成 1 个空格，把行首尾的空格全部删掉，把标点符号前面的空格删掉；
  • 把原文中所有大写英文字母变成小写，除了 I；
  • 把原文中所有独立的 can you、could you 对应地换成 I can、I could—— 这里“独立”是指被空格或标点符号分隔开的单词；
  • 把原文中所有独立的 I 和 me 换成 you；
  • 把原文中所有的问号 ? 换成惊叹号 !；
  • 在一行中输出替换后的句子作为 AI 的回答。

输入格式：

输入首先在第一行给出不超过 10 的正整数 N，随后 N 行，每行给出一句不超过 1000 个字符的、以回车结尾的用户的对话，对话为非空字符串，仅包括字母、数字、空格、可见的半角标点符号。

输出格式：

按题面要求输出，每个 AI 的回答前要加上 AI: 和一个空格。

输入样例：

  1. 6
  2. Hello ?
  3.  Good to chat   with you
  4. can   you speak Chinese?
  5. Really?
  6. Could you show me 5
  7. What Is this prime? I,don 't know

输出样例：

  1. Hello ?
  2. AI: hello!
  3.  Good to chat   with you
  4. AI: good to chat with you
  5. can   you speak Chinese?
  6. AI: I can speak chinese!
  7. Really?
  8. AI: really!
  9. Could you show me 5
  10. AI: I could show you 5
  11. What Is this prime? I,don 't know
  12. AI: what Is this prime! you,don't know

代码实现: 

  1. #include<stdio.h>
  2. #include<ctype.h>
  3. //判断是否为空格or非字母非数字字符
  4. int Judge(char p)
  5. {
  6. 	if ((p >= 'A' && p <= 'Z') || (p >= 'a' && p <= 'z') || (p >= '0' && p <= '9'))
  7. 	{
  8. 		return 0;
  9. 	}
  10. 	else
  11. 	{
  12. 		return 1;
  13. 	}
  14. }
  15.  
  16. //去除空格
  17. void DelBlank(char arr[], int len)
  18. {
  19. 	int i = 0;
  20. 	for (i = 0; i < len; i++)
  21. 	{
  22. 		//处理开头的空格
  23. 		if (arr[0] == ' ')
  24. 		{
  25. 			int j = 0;
  26. 			for (j = 0; j < len; j++)
  27. 			{
  28. 				arr[j] = arr[j + 1];
  29. 			}
  30. 		}
  31.  
  32. 		if (arr[i] == ' ')
  33. 		{
  34. 			int flag = Judge(arr[i + 1]);
  35. 			if (flag == 1)
  36. 			{
  37. 				int k = 0;
  38. 				for (k = i; k < len; k++)
  39. 				{
  40. 					arr[k] = arr[k + 1];
  41. 				}
  42. 				i--;
  43. 			}
  44. 		}
  45. 	}
  46. }
  47.  
  48. //大写转小写
  49. void Tolower(char arr[], int len)
  50. {
  51. 	int i = 0;
  52. 	for (i = 0; i < len; i++)
  53. 	{
  54. 		if (arr[i] != 'I')
  55. 		{
  56. 			arr[i] = tolower(arr[i]);
  57. 		}
  58. 	}
  59. }
  60.  
  61. //替换并打印最终结果
  62. void ReplacePrint(char arr[])
  63. {
  64. 	printf("AI: ");
  65.  
  66. 	int i = 0;
  67. 	for (i = 0; i < strlen(arr); i++)
  68. 	{
  69. 		if ((arr[i] == 'c' && arr[i + 1] == 'a' && arr[i + 2] == 'n' && arr[i + 3] == ' ' && arr[i + 4] == 'y' && arr[i + 5] == 'o' && arr[i + 6] == 'u') && (i == 0 || arr[i - 1] == ' ') && (arr[i + 7] == ' ' || arr[i + 7] == '\0' || Judge(arr[i + 7])))
  70. 		{
  71. 			printf("I can");
  72. 			i += 6;
  73. 		}
  74. 		else if ((arr[i] == 'c' && arr[i + 1] == 'o' && arr[i + 2] == 'u' && arr[i + 3] == 'l' && arr[i + 4] == 'd' && arr[i + 5] == ' ' && arr[i + 6] == 'y' && arr[i + 7] == 'o' && arr[i + 8] == 'u') && (i == 0 || arr[i - 1] == ' ') && (arr[i + 9] == ' ' || arr[i + 9] == '\0' || Judge(arr[i + 9])))
  75. 		{
  76. 			printf("I could");
  77. 			i += 8;
  78. 		}
  79. 		else if (arr[i] == 'I' && (i == 0 || arr[i - 1] == ' ') && (arr[i + 1] == ' ' || arr[i + 1] == '\0' || Judge(arr[i + 1])))
  80. 		{
  81. 			printf("you");
  82. 		}
  83. 		else if ((arr[i] == 'm' && arr[i + 1] == 'e') && (i == 0 || arr[i - 1] == ' ') && (arr[i + 2] == ' ' || arr[i + 2] == '\0' || Judge(arr[i + 2])))
  84. 		{
  85. 			printf("you");
  86. 			i += 1;
  87. 		}
  88. 		else
  89. 		{
  90. 			printf("%c", arr[i]);
  91. 		}
  92. 	}
  93. }
  94.  
  95. void Change(char arr[], int len)
  96. {
  97. 	int i = 0;
  98. 	for (i = 0; i < len; i++)
  99. 	{
  100. 		if (arr[i] == '?')
  101. 		{
  102. 			arr[i] = '!';
  103. 		}
  104. 	}
  105. }
  106.  
  107. int main()
  108. {
  109. 	int n = 0;
  110. 	scanf("%d", &n);
  111. 	getchar();
  112. 	char arr[1001] = { 0 };
  113. 	int i = 0;
  114. 	for (i = 0; i < n; i++)
  115. 	{
  116. 		gets(arr);
  117. 		printf("%s\n", arr);
  118. 		int len = strlen(arr);
  119. 		DelBlank(arr, len);
  120. 		Tolower(arr, len);
  121. 		Change(arr, len);
  122. 		ReplacePrint(arr);
  123. 		printf("\n");
  124. 	}
  125. 	return 0;
  126. }

大致思路:

1 去除空格 : 分两种空格 

 a. 不在开头的空格

遍历字符数组,当发现当前元素是一个空格,需要判断这个元素后面的另一个元素是否为空格or非数字非字母字符,若是,则需要消除多余空格,操作是覆盖法,让这个为空格的元素的后面的所有元素都往前挪一个位置,构成覆盖效果

比如:Hello ?

?前面是一个空格,这种空格是需要被删除的,即一个不需要删除的空格的后面可以是字母,数字,需要删除的空格它的后面是非数字非字母字符,空格

show me 5:第一个空格后面是字母,合法,第二个空格后面是数字,合法,这些空格都不需要删除

Hello ?        这个空格的后面是非数字非字母字符,非法,此空格需要删除

b. 在最开头的空格:可能是一个or多个

 无论是一个or多个空格出现在最开头我们都需要全部消除,若是存在多个空格且最后一个空格后面紧跟着的是字母,则a中所提的消除空格的代码不会执行,故而我们要将出现在开头的空格的消除单独再使用这个覆盖法:让这个为空格的元素的后面的所有元素都往前挪一个位置

2 大写转小写

遍历整个字符数组,所有大写英文字母变成小写，除了 I

可以使用库函数tolower

3 ?变成!

4 替换独立的 can you、could you ->I can、I could

        I 和 me 换成 you

在字符数组中一个字符一个字符的对应can you、could you ,I , me

对应之后,不打印can you、could you ,而是打印I can、I could

      不打印I , me,而是打印you

若是字符数组中没有完整连续对应上述这些内容,则正常一个一个输出字符

若是完整连续对应上了,在替换打印后,需要要打印can you,could you,I , me之后剩下的所有字符

 代码解读

主体部分

  1. int main()
  2. {
  3. 	int n = 0;
  4. 	scanf("%d", &n);
  5. 	getchar();//读取数字之后的换行符\n
  6. 	char arr[1001] = { 0 };
  7. 	int i = 0;
  8. 	for (i = 0; i < n; i++)
  9. 	{
  10. 		gets(arr);
  11. 		printf("%s\n", arr);
  12. 		int len = strlen(arr);
  13. 		DelBlank(arr, len);//删除多余空格
  14. 		Tolower(arr, len);//大写转成小写
  15. 		Change(arr, len);//?->!
  16. 		ReplacePrint(arr);//替换can you、could you,I , me并输出已调整好只需替换某些内容的字符串
  17. 		printf("\n");
  18. 	}
  19. 	return 0;
  20. }

 使用get读取带有空格的字符串,,注意需要使用getchar读取\n

函数部分

part 1 删除多余空格

  1. void DelBlank(char arr[], int len)
  2. {
  3. 	int i = 0;
  4. 	for (i = 0; i < len; i++)
  5. 	{
  6. 		//处理开头的空格
  7. 		if (arr[0] == ' ')
  8. 		{
  9. 			int j = 0;
  10. 			for (j = 0; j < len; j++)
  11. 			{
  12. 				arr[j] = arr[j + 1];
  13. 			}
  14. 		}
  15.  
  16. 		if (arr[i] == ' ')
  17. 		{
  18. 			int flag = Judge(arr[i + 1]);
  19. 			if (flag == 1)
  20. 			{
  21. 				int k = 0;
  22. 				for (k = i; k < len; k++)
  23. 				{
  24. 					arr[k] = arr[k + 1];
  25. 				}
  26. 				i--;//覆盖掉当前为空格的元素后,需要i--,因为在循环中下一步就是执行i++,先退一步,再前进一步==原地不动,就能再次判断这个位置是否覆盖的新值仍为空格
  27. 			}
  28. 		}
  29. 	}
  30. }

空格分为:字符串开头处的空格非开头处的空格

非开头处空格的处理:

遍历整个字符数组,若是当前元素是空格,且进一步判断是需要删除的空格,则使用覆盖法,用它后面的人来覆盖它,即此空格后面的所有元素都往前移动一位

注意:由于存在连续空格的情况,即检查出当前元素是空格,使用覆盖法,这个空格位置覆盖上来的又是一个空格,不能直接++,跳过这个已经检查过的位置,判断下一个位置,而是需要先--,这样就又能重新判断这个被覆盖上新值的位置是否仍为空格

a. 判断出当前元素是空格,下一步就是判断这个空格是否需要删除

一个需要删除的空格的条件:它后面的一个元素不是字母,不是数字,即它后面的元素是非字母非数字字符

Judge函数就是判断一个元素是否为非字母非数字字符,返回值为1表示此元素是非字母非数字字符,返回0表示此元素是数字或者字母

开头处空格的处理:

开头处空格比较特殊,都需要删除,而上面所提的删除空格的代码执行的条件是当前空格后面的一个元素需要是非数字非字母字符

而开头处的空格,它后面的一个元素可能是字母,故而不能满足这个条件,若是它两统统都使用着一个删除空格的代码,则肯定是行不通的

我们另外设计一个专门删除开头处的空格的代码,只要开头处(即字符数组的首元素arr[0])是空格,我们就会删除掉这个空格:

  1.         if (arr[0] == ' ')
  2. 		{
  3. 			int j = 0;
  4. 			for (j = 0; j < len; j++)
  5. 			{
  6. 				arr[j] = arr[j + 1];
  7. 			}
  8. 		}

part 2 大写转小写

  1. //大写转小写
  2. void Tolower(char arr[], int len)
  3. {
  4. 	int i = 0;
  5. 	for (i = 0; i < len; i++)
  6. 	{
  7. 		if (arr[i] != 'I')
  8. 		{
  9. 			arr[i] = tolower(arr[i]);
  10. 		}
  11. 	}
  12. }

遍历整个字符数组,使用tolower函数将大写字母转成小写字母

tolower函数的头文件:

#include <ctype.h>

part 3 ?->!

  1. void Change(char arr[], int len)
  2. {
  3. 	int i = 0;
  4. 	for (i = 0; i < len; i++)
  5. 	{
  6. 		if (arr[i] == '?')
  7. 		{
  8. 			arr[i] = '!';
  9. 		}
  10. 	}
  11. }

part 4 输出已经调整好的只需替换某些内容的字符串

  1. //替换并打印最终结果
  2. void ReplacePrint(char arr[])
  3. {
  4. 	printf("AI: ");
  5.  
  6. 	int i = 0;
  7. 	for (i = 0; i < strlen(arr); i++)
  8. 	{
  9. 		if ((arr[i] == 'c' && arr[i + 1] == 'a' && arr[i + 2] == 'n' && arr[i + 3] == ' ' && arr[i + 4] == 'y' && arr[i + 5] == 'o' && arr[i + 6] == 'u') && (i == 0 || arr[i - 1] == ' ') && (arr[i + 7] == ' ' || arr[i + 7] == '\0' || Judge(arr[i + 7])))
  10. 		{
  11. 			printf("I can");
  12. 			i += 6;//要打印can you之后的剩余字符,从下标i+=7开始,所以先将i(此时是c的下标)加上6(即u的下标,马上要执行的下一条语句是i++,就能使得i成为can you之后的剩余字符的第一个字符的下标
  13. 		}
  14. 		else if ((arr[i] == 'c' && arr[i + 1] == 'o' && arr[i + 2] == 'u' && arr[i + 3] == 'l' && arr[i + 4] == 'd' && arr[i + 5] == ' ' && arr[i + 6] == 'y' && arr[i + 7] == 'o' && arr[i + 8] == 'u') && (i == 0 || arr[i - 1] == ' ') && (arr[i + 9] == ' ' || arr[i + 9] == '\0' || Judge(arr[i + 9])))
  15. 		{
  16. 			printf("I could");
  17. 			i += 8;//要打印could you之后的剩余字符,从下标i+=9开始,所以先将i(此时是c的下标)加上8(即u的下标,马上要执行的下一条语句是i++,就能使得i成为could you之后的剩余字符的第一个字符的下标
  18. 		}
  19. 		else if (arr[i] == 'I' && (i == 0 || arr[i - 1] == ' ') && (arr[i + 1] == ' ' || arr[i + 1] == '\0' || Judge(arr[i + 1])))
  20. 		{
  21. 			printf("you");
  22. 		}
  23. 		else if ((arr[i] == 'm' && arr[i + 1] == 'e') && (i == 0 || arr[i - 1] == ' ') && (arr[i + 2] == ' ' || arr[i + 2] == '\0' || Judge(arr[i + 2])))
  24. 		{
  25. 			printf("you");
  26. 			i += 1;//要打印me之后的剩余字符,从下标i+=2开始,所以先将i(此时是c的下标)加上1(即e的下标,马上要执行的下一条语句是i++,就能使得i成为me之后的剩余字符的第一个字符的下标
  27. 		}
  28. 		else
  29. 		{
  30. 			printf("%c", arr[i]);
  31. 		}
  32. 	}
  33. }

在字符数组中若不能找到完整连续的can you,could you, I ,me,则一个字符一个字符地输出内容

这是无需替换的正常字符

若是字符数组中能找到完整连续的can you, could you ,I me,则打印I can、I could,you,代替can you, could you ,I me的打印

判断完整连续的独立can you:

can you可以出现在字符串的开头/末尾/中间

独立(隔开)can you: 分为前和后两部分,就像两条线将can you 围住

前一条线: 字符c的下标是0(can you 出现在开头) 或者 字符c的前一个元素是空格(can you 出现在字符串中)

后一条线: 字符u的后一个元素是空格or标点符号or \0

could you ,I me的独立判断同上

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/277187?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号