7-1 字符串循环左移
输入一个字符串和一个非负整数N，要求将字符串循环左移N次。
输入格式：
输入在第1行中给出一个不超过100个字符长度的、以回车结束的非空字符串；第2行给出非负整数N。
输出格式：
在一行中输出循环左移N次后的字符串。
输入样例：
Hello World!
2
输出样例：
llo World!He
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
具体代码实现：
import java.util.*;
public class Main{
public static void main(String[]args){
Scanner reader=new Scanner(System.in);
String a=reader.nextLine();
int n=Integer.parseInt(reader.nextLine());
int i,j;
char []c=a.toCharArray();
for(i=0;i<n;i++)
{char b=c[0];
for(j=0;j<a.length()-1;j++)
{
c[j]=c[j+1];
}
c[c.length-1]=b;
}
for(i=0;i<c.length;i++)
System.out.print(c[i]);
}
}7-2 说反话-加强版
给定一句英语，要求你编写程序，将句中所有单词的顺序颠倒输出。
输入格式：
测试输入包含一个测试用例，在一行内给出总长度不超过500 000的字符串。字符串由若干单词和若干空格组成，其中单词是由英文字母（大小写有区分）组成的字符串，单词之间用若干个空格分开。
输出格式：
每个测试用例的输出占一行，输出倒序后的句子，并且保证单词间只有1个空格。
import java.io.IOException;
import java.text.ParseException;
import java.util.Scanner;
/*
* */
public class Main {
public static void main(String[] args) throws ParseException, IOException {
Scanner scanner = new Scanner(System.in);
//输入一组单词,去除掉前后空格
String str = scanner.nextLine().trim();
//去除掉单词间的空格,可能不只有一个空格，因此用" +"表示至少一个空格
String[] strs = str.split(" +");
for(int i=strs.length-1;i>=0;--i)
{
System.out.print(strs[i]);
if(i!=0)
System.out.print(" ");
//不是最后一个单词，就输出一个空格
}
}
}7-3 单词长度
你的程序要读入一行文本，其中以空格分隔为若干个单词，以.结束。你要输出每个单词的长度。这里的单词与语言无关，可以包括各种符号，比如it's算一个单词，长度为4。注意，行中可能出现连续的空格；最后的.不计算在内。
输入格式：
输入在一行中给出一行文本，以.结束
提示：用scanf("%c",...);来读入一个字符，直到读到.为止。
输出格式：
在一行中输出这行文本对应的单词的长度，每个长度之间以空格隔开，行末没有最后的空格。
输入样例：
It's great to see you here.
输出样例：
4 5 2 3 3 4import java.util.*;
public class Main{
public static void main(String[]args){
Scanner reader=new Scanner(System.in);
String []a=reader.nextLine().split(" ");
int t=0;
for(int i=a.length-1;i>=0;i--)
if(!a[i].equals("")&&!a[i].equals("."))
{ t=i;
break;}
for(int i=0;i<a.length;i++)
if(!a[i].equals("")) {
if (i != a.length - 1)
if(i!=t)
{System.out.print(a[i].length() + " ");}
else
{System.out.print(a[i].length());
}
else
if(!a[i].equals("."))
System.out.print(a[i].length() - 1);}
}
}7-4 九宫格输入法
假设有九宫格输入法键盘布局如下：
[ 1,.?! ] [ 2ABC ] [ 3DEF ]
[ 4GHI ] [ 5JKL ] [ 6MNO ]
[ 7PQRS ] [ 8TUV ] [ 9WXYZ ]
[ 0空 ]
注意：中括号[ ]仅为了表示键盘的分隔，不是输入字符。每个中括号中，位于首位的数字字符即是键盘的按键，按一下即可输入该数字字符。多次按同一个键，则输入的字符依次循环轮流，例如按两次3，则输入D；按5次7，则输入S；按6次2，则输入A。按键0的输入组合是0和空格字符，即按两次0输入空格。
你需要对于给定的按键组合，给出该组合对应的文本。
输入格式:
输入在一行中给出数个字符的按键组合（例如 999 表示按3次9），每个字符的按键组合之间用空格间隔，最后一个输入法组合之后以换行结束。输入数据至少包括一个字符的按键组合，且输入总长度不超过500个字符。
输出格式:
在一行中输出该按键组合对应的文本。
输入样例:
22 5555 22 666 00 88 888 7777 4444 666 44
输出样例:
ALAN TURINGimport java.util.*;
public class Main{
public static void main(String[]args) {
Scanner reader = new Scanner(System.in);
String[] a = reader.nextLine().split(" ");
char[][] b = {{'0', ' '}, {'1', ',', '.', '?', '!'}, {'2', 'A', 'B', 'C'}, {'3', 'D', 'E', 'F'}, {'4', 'G', 'H', 'I'}, {'5', 'J', 'K', 'L'}, {'6', 'M', 'N', 'O'}, {'7', 'P', 'Q', 'R', 'S'
}, {'8', 'T', 'U', 'V'}, {'9', 'W', 'X', 'Y', 'Z'}};
int i;
for (i = 0; i < a.length; i++) {
int m = a[i].charAt(0) - '0';
int n=a[i].length();
int p=b[a[i].charAt(0) - '0'].length;
System.out.printf("%s", b[m][(n-1)%p ]);
}
}
}7-5 抓老鼠啊~亏了还是赚了？
某地老鼠成灾，现悬赏抓老鼠，每抓到一只奖励10元，于是开始跟老鼠斗智斗勇：每天在墙角可选择以下三个操作：放置一个带有一块奶酪的捕鼠夹(T)，或者放置一块奶酪(C)，或者什么也不放(X)。捕鼠夹可重复利用，不计成本，奶酪每块3元。
聪明的老鼠呢？它们每天可能会派出一只老鼠到墙角，看看墙角有啥：
- 若什么也没有(
X)，老鼠们就不高兴了(Unhappy)，会有长达一天（也就是第二天）的不高兴期。在不高兴期间，不派出老鼠。不高兴期结束之后，派出老鼠。 - 若有捕鼠夹(
T)，这只老鼠被引诱吃掉奶酪并被打死(Dead)，老鼠们会有长达两天（也就是第二和第三天）的伤心期。在伤心期间，不派出老鼠。伤心期结束之后，派出老鼠。在这种情况下，抓到1只老鼠可获得奖励10元，但同时也耗费了一块奶酪。注意，如果某一天放置了捕鼠夹但老鼠没有出现，则没有耗费奶酪。 - 若有奶酪(
C)，老鼠吃了奶酪会很开心(Happy!)，会有长达两天（第二和第三天）的兴奋期。在兴奋期间，即使叠加了不高兴或者伤心，也必定派出老鼠。在这种情况下，没抓到老鼠，而且耗费了一块奶酪。注意，如果某一天放置了奶酪但老鼠没有出现，则奶酪可以下次再用，没有耗费。
现在给你连续几天的操作序列，且已知第一天肯定会派出老鼠，请判断老鼠每天的状态，并计算盈利。
输入格式:
输入在一行中给出连续的由C或T或X组成的不超过70个字符的字符串，以$结束。字符串中每个字符表示这一天的操作( 即X：什么都不放；T：放捕鼠夹；C：放奶酪）。题目保证至少有一天的操作输入。
输出格式:
要求在第一行输出连续的字符串，与输入相对应，给出老鼠的状态：
!表示派出老鼠吃到奶酪D表示派出老鼠被打死U表示派出老鼠无所获-表示没有派出老鼠
第二行则应输出一个整数表示盈利。（如果有亏损，则是负数）
输入样例1:
TXXXXC$
输出样例1:
D--U-!
4
输入样例2:
CTTCCX$
输出样例2:
!DD--U
11
import javax.sound.midi.SysexMessage;
import java.util.*;
public class Main{
public static void main(String[]args){
Scanner reader=new Scanner(System.in);
String a=reader.nextLine();
int i;
int sum=0;
int count=0;
int f=0;
for (i=0;i<a.length();i++) {
if (a.charAt(i) == '$')
break;
if(f!=0) {
if (a.charAt(i) == 'T') {
System.out.print("D");
f--;
count = 2;
sum=sum+7;
continue;}
if(a.charAt(i) == 'X' ) {
System.out.print("U");
f--;
continue;
}
if(a.charAt(i) == 'C' ) {
System.out.print("!");
f=2;
sum=sum-3;
continue;
}
}
else {
if (a.charAt(i) == 'T' && count == 0) {
{
System.out.print("D");
count = 2;
sum=sum+7;
continue;
}
}
}
if (count != 0) {
System.out.print("-");
count--;
}
else {
if (a.charAt(i) == 'X') {
System.out.print("U");
count = 1;
}
if (a.charAt(i) == 'C') {
System.out.print("!");
f=2;
sum=sum-3;
}
}
}
System.out.println();
System.out.print(sum);
}
}
7-6 大炮打蚊子
现在，我们用大炮来打蚊子：蚊子分布在一个M×N格的二维平面上，每只蚊子占据一格。向该平面的任意位置发射炮弹，炮弹的杀伤范围如下示意：
O
OXO
O
其中，X为炮弹落点中心，O为紧靠中心的四个有杀伤力的格子范围。若蚊子被炮弹命中（位于X格），一击毙命，若仅被杀伤（位于O格），则损失一半的生命力。也就是说，一次命中或者两次杀伤均可消灭蚊子。现在给出蚊子的分布情况以及连续k发炮弹的落点，给出每炮消灭的蚊子数。
输入格式:
第一行为两个不超过20的正整数M和N，中间空一格，表示二维平面有M行、N列。
接下来M行，每行有N个0或者#字符，其中#表示所在格子有蚊子。
接下来一行，包含一个不超过400的正整数k，表示发射炮弹的数量。
最后k行，每行包括一发炮弹的整数坐标x和y（0≤x<M，0≤y<N），之间用一个空格间隔。
输出格式:
对应输入的k发炮弹，输出共有k行，第i行即第i发炮弹消灭的蚊子数。
输入样例:
5 6
00#00#
000###
00#000
000000
00#000
2
1 2
1 4
输出样例:
0
2
import java.util.*;
public class Main{
public static void main(String[]args){
Scanner reader=new Scanner(System.in);
int m=reader.nextInt();
int n=reader.nextInt();
String []a=new String[m];
int i,j;
for(i=0;i<m;i++)
a[i]=reader.next();
String[][]d=new String[m][n];
for(i=0;i<m;i++)
for(j=0;j<n;j++)
d[i][j]= String.valueOf(a[i].charAt(j));
int k=reader.nextInt();
int [][]b=new int[k][2];
for(i=0;i<k;i++)
for(j=0;j<2;j++)
b[i][j]=reader.nextInt();
int [][]c=new int[m][n];
if(m==1&&n==1)
{for(i = 0; i < k; i++)
{ int count=0;
if(d[b[i][0]][b[i][1]].equals("#"))
{
count++;
System.out.println(count);
d[b[i][0]][b[i][1]]="";
}else
System.out.println("0");}
}
else {
for (i = 0; i < k; i++) {
int count = 0;
if (b[i][0] > 0 && b[i][0] < m - 1 && b[i][1] > 0 && b[i][1] < n - 1) {
c[b[i][0] - 1][b[i][1]] = c[b[i][0] - 1][b[i][1]] + 1;
c[b[i][0] + 1][b[i][1]] = c[b[i][0] + 1][b[i][1]] + 1;
c[b[i][0]][b[i][1] - 1] = c[b[i][0]][b[i][1] - 1] + 1;
c[b[i][0]][b[i][1] + 1] = c[b[i][0]][b[i][1] + 1] + 1;
} else if (b[i][0] == 0 && b[i][1] == 0) {
c[b[i][0] + 1][b[i][1]] = c[b[i][0] + 1][b[i][1]] + 1;
c[b[i][0]][b[i][1] + 1] = c[b[i][0]][b[i][1] + 1] + 1;
} else if (b[i][0] == m - 1 && b[i][1] == n - 1) {
c[b[i][0] - 1][b[i][1]] = c[b[i][0] - 1][b[i][1]] + 1;
c[b[i][0]][b[i][1] - 1] = c[b[i][0]][b[i][1] - 1] + 1;
} else if (b[i][0] == 0 && b[i][1] == n - 1) {
c[b[i][0] + 1][b[i][1]] = c[b[i][0] + 1][b[i][1]] + 1;
c[b[i][0]][b[i][1] - 1] = c[b[i][0]][b[i][1] - 1] + 1;
} else if (b[i][0] == m - 1 && b[i][1] == 0) {
c[b[i][0] - 1][b[i][1]] = c[b[i][0] - 1][b[i][1]] + 1;
c[b[i][0]][b[i][1] + 1] = c[b[i][0]][b[i][1] + 1] + 1;
} else {
if (b[i][1] == 0) {
c[b[i][0] + 1][b[i][1]] = c[b[i][0] + 1][b[i][1]] + 1;
c[b[i][0]][b[i][1] + 1] = c[b[i][0]][b[i][1] + 1] + 1;
c[b[i][0] - 1][b[i][1]] = c[b[i][0] - 1][b[i][1]] + 1;
} else if (b[i][0] == 0) {
c[b[i][0] + 1][b[i][1]] = c[b[i][0] + 1][b[i][1]] + 1;
c[b[i][0]][b[i][1] + 1] = c[b[i][0]][b[i][1] + 1] + 1;
c[b[i][0]][b[i][1] - 1] = c[b[i][0]][b[i][1] - 1] + 1;
} else if (b[i][1] == n - 1) {
c[b[i][0] - 1][b[i][1]] = c[b[i][0] - 1][b[i][1]] + 1;
c[b[i][0]][b[i][1] - 1] = c[b[i][0]][b[i][1] - 1] + 1;
c[b[i][0] + 1][b[i][1]] = c[b[i][0] + 1][b[i][1]] + 1;
} else {
c[b[i][0]][b[i][1] - 1] = c[b[i][0]][b[i][1] - 1] + 1;
c[b[i][0]][b[i][1] + 1] = c[b[i][0]][b[i][1] + 1] + 1;
c[b[i][0] - 1][b[i][1]] = c[b[i][0] - 1][b[i][1]] + 1;
}
}
if (d[b[i][0]][b[i][1]].equals("#")) {
count++;
d[b[i][0]][b[i][1]] = "";
}
for (int p = 0; p < m; p++)
for (int q = 0; q < n; q++)
if (d[p][q].equals("#") && c[p][q] == 2) {
count++;
d[p][q] = "";
}
System.out.println(count);
}
}
}
}
7-7 切分表达式——写个tokenizer吧
[先说点出题背景]
这个题是为低年级同学、学C语言的同学准备的，因为，对这部分同学，这个题目编写起来略有一点复杂。如果是高年级、学过了正则表达式（Regular Expression）的同学或者学过了Java等OO语言的同学做这个题，应当发现这题比较简单吧。哦，对了，什么是tokenizer？请自行查询解决。反正在此处不应翻译成“令牌解析器”。
[正题]
四则运算表达式由运算数（必定包含数字，可能包含正或负符号、小数点）、运算符（包括+、-、*、/）以及小括号（(和)）组成，每个运算数、运算符和括号都是一个token（标记）。现在，对于给定的一个四则运算表达式，请把她的每个token切分出来。题目保证给定的表达式是正确的，不需要做有效性检查。
输入格式:
在一行中给出长度不超过40个字符的表达式，其中没有空格，仅由上文中token的字符组成
输出格式:
依次输出表达式中的tokens，每个token占一行。
输入样例:
32*((2-2)+5)/(-15)
输出样例:
32
*
(
(
2
-
2
)
+
5
)
/
(
-15
)import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
String s=sc.next();
for(int i=0;i<s.length();i++){
char ch=s.charAt(i);
System.out.printf("%c",ch);
if(i+1==s.length())
System.out.printf("%n");
else if(ch>='0'&&ch<='9'&&!(s.charAt(i+1)>='0'&&s.charAt(i+1)<='9')&&s.charAt(i+1)!='.')
System.out.printf("%n");
else if(ch=='*'||ch=='/'||ch=='('||ch==')')
System.out.printf("%n");
else if((ch=='+'||ch=='-')&&i-1!=-1){
if(s.charAt(i-1)==')'||s.charAt(i-1)>='0'&&s.charAt(i-1)<='9')
System.out.printf("%n");
}
}
}
}
7-8 编程打印空心字符菱形
本题目要求读入菱形起始字母和菱形的高度，然后输出空心字符菱形。所谓“空心菱形”是指：每行由两端为字母、中间为空格的字符串构成，每行的字符串中心对齐；上半部分相邻两行字符串长度差2，且字母从给定的起始字母逐一递增；下半部分与上半部分对称。
输入格式:
输入在一行中给出起始字母（范围为英文大写字母A-G）和菱形的高度（为不超过10的奇数）。
输出格式:
输出空心字符菱形。
输入样例:
B 5
输出样例:
B
C C
D D
C C
Bimport java.awt.*;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner reader=new Scanner(System.in);
char a=reader.next().charAt(0);
int n= reader.nextInt();
int i,j,p;
for(i=0;i<(n+1)/2;i++)
{
for(j=0;j<(n-1)/2-i;j++)
System.out.print(" ");
if(i==0)
{System.out.printf("%c\n",a);
continue;}
else
{System.out.printf("%c",a+i);
for(p=0;p<2*i-1;p++)
System.out.print(" ");
System.out.printf("%c",a+i);
}
System.out.println();
}
for(i=0;i<(n-1)/2;i++)
{
for(j=1;j+i>0;j--)
System.out.print(" ");
if(i==(n-1)/2-1) {
System.out.printf("%c", a);
}else
{System.out.printf("%c",a+(n-1)/2-1-i);
for(p=n-4;p-2*i>0;p--)
System.out.print(" ");
System.out.printf("%c",a+(n-1)/2-1-i);
}
System.out.println();
}
}
}
7-9 到底有多二
一个整数“犯二的程度”定义为该数字中包含2的个数与其位数的比值。如果这个数是负数，则程度增加0.5倍；如果还是个偶数，则再增加1倍。例如数字-13142223336是个11位数，其中有3个2，并且是负数，也是偶数，则它的犯二程度计算为：3/11×1.5×2×100%，约为81.82%。本题就请你计算一个给定整数到底有多二。
输入格式：
输入第一行给出一个不超过50位的整数N。
输出格式：
在一行中输出N犯二的程度，保留小数点后两位。
输入样例：
-13142223336
输出样例：
81.82%import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner reader=new Scanner(System.in);
String a= reader.next();
//位数
int length=a.length();
double cd=1;
if(a.charAt(0)=='-') {
length = length - 1;
cd=cd*1.5;
}
if((a.charAt(a.length()-1)-'0')%2==0)
cd=cd*2;
double ci=0;
for(int i=0;i<a.length();i++)
if(a.charAt(i)=='2')
ci++;
System.out.printf("%.2f",ci/length*cd*100);
System.out.print("%");
}
}
7-10 输出GPLT
给定一个长度不超过10000的、仅由英文字母构成的字符串。请将字符重新调整顺序，按GPLTGPLT....这样的顺序输出，并忽略其它字符。当然，四种字符（不区分大小写）的个数不一定是一样多的，若某种字符已经输出完，则余下的字符仍按GPLT的顺序打印，直到所有字符都被输出。
输入格式：
输入在一行中给出一个长度不超过10000的、仅由英文字母构成的非空字符串。
输出格式：
在一行中按题目要求输出排序后的字符串。题目保证输出非空。
输入样例：
pcTclnGloRgLrtLhgljkLhGFauPewSKgt
输出样例：
GPLTGPLTGLTGLGLLimport java.util.*;
public class Main {
public static void main(String[] args) {
Scanner reader=new Scanner(System.in);
StringBuilder a= new StringBuilder(reader.nextLine());
int i;
int x=0,y=0,z=0,w=0;
for(i=0;i<a.length();i++) {
if (a.charAt(i) == 'G' || a.charAt(i) == 'g')
x++;
if (a.charAt(i) == 'P' || a.charAt(i) == 'p')
y++;
if (a.charAt(i) == 'L' || a.charAt(i) == 'l')
z++;
if (a.charAt(i) == 'T' || a.charAt(i) == 't')
w++;
}
int max=0;
int []b={x,y,z,w};
for(i=0;i<b.length;i++)
if(b[max]<b[i])
max=i;
for(i=0;i<b[max];i++)
{if(x!=0)
{System.out.print("G");
x--;}
if(y!=0)
{ System.out.print("P");
y--;}
if(z!=0)
{ System.out.print("L");
z--;}
if(w!=0)
{ System.out.print("T");
w--;}
}
}
}
7-11 出租
下面是新浪微博上曾经很火的一张图：
一时间网上一片求救声，急问这个怎么破。其实这段代码很简单，index数组就是arr数组的下标，index[0]=2 对应 arr[2]=1，index[1]=0 对应 arr[0]=8，index[2]=3 对应 arr[3]=0，以此类推…… 很容易得到电话号码是18013820100。
本题要求你编写一个程序，为任何一个电话号码生成这段代码 —— 事实上，只要生成最前面两行就可以了，后面内容是不变的。
输入格式：
输入在一行中给出一个由11位数字组成的手机号码。
输出格式：
为输入的号码生成代码的前两行，其中arr中的数字必须按递减顺序给出。
输入样例：
18013820100
输出样例：
int[] arr = new int[]{8,3,2,1,0};
int[] index = new int[]{3,0,4,3,1,0,2,4,3,4,4};import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
String a = reader.nextLine();
int i;
String b = "";
for (i = 0; i < a.length(); i++) {
String c = "" + a.charAt(i);
if (!b.contains(c))
b = b + c;
}
char[] d = b.toCharArray();
int j;
char temp;
for (i = 0; i < d.length - 1; i++) {
int maxIndex = i;
for (j = i + 1; j < d.length; j++) {
if (d[maxIndex] < d[j]) {
maxIndex = j;
}
}
temp = d[i];
d[i] = d[maxIndex];
d[maxIndex] = temp;
}
System.out.print("int[] arr = new int[]{");
for (i = 0; i < d.length; i++)
if (i != d.length - 1)
System.out.printf("%c,", d[i]);
else
System.out.printf("%c};\n", d[i]);
String e = "";
for (i = 0; i < a.length(); i++)
for (j = 0; j < d.length; j++)
if (a.charAt(i) == d[j])
e = e + j;
System.out.print("int[] index = new int[]{");
for (i = 0; i < e.length(); i++)
if (i != e.length() - 1) {
System.out.printf("%c,",e.charAt(i));
}else {
System.out.printf("%c};",e.charAt(i));
}
}
}
7-12 Left-pad
根据新浪微博上的消息，有一位开发者不满NPM（Node Package Manager）的做法，收回了自己的开源代码，其中包括一个叫left-pad的模块，就是这个模块把javascript里面的React/Babel干瘫痪了。这是个什么样的模块？就是在字符串前填充一些东西到一定的长度。例如用*去填充字符串GPLT，使之长度为10，调用left-pad的结果就应该是******GPLT。Node社区曾经对left-pad紧急发布了一个替代，被严重吐槽。下面就请你来实现一下这个模块。
输入格式：
输入在第一行给出一个正整数N（≤104）和一个字符，分别是填充结果字符串的长度和用于填充的字符，中间以1个空格分开。第二行给出原始的非空字符串，以回车结束。
输出格式：
在一行中输出结果字符串。
输入样例1：
15 _
I love GPLT
输出样例1：
____I love GPLT
输入样例2：
4 *
this is a sample for cut
输出样例2：
cutimport java.util.*;
public class Main {
public static void main(String[] args) {
Scanner reader=new Scanner(System.in);
int n= reader.nextInt();
char a=reader.next().charAt(0);
reader.nextLine();
StringBuilder b=new StringBuilder(reader.nextLine());
int count=0;
if(b.length()<n)
count=n-b.length();
int i;
if(b.length()<n)
{for(i=0;i<count;i++)
System.out.print(a);
System.out.print(b);
}
else
{
System.out.print(b.substring(b.length()-n,b.length()));}
}
}
7-13 最长对称子串
对给定的字符串，本题要求你输出最长对称子串的长度。例如，给定Is PAT&TAP symmetric?，最长对称子串为s PAT&TAP s，于是你应该输出11。
输入格式：
输入在一行中给出长度不超过1000的非空字符串。
输出格式：
在一行中输出最长对称子串的长度。
输入样例：
Is PAT&TAP symmetric?
输出样例：
11
import java.io.*;
public class Main{
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s = br.readLine();
System.out.print(longestPalindrome(s));
}
static int longestPalindrome(String s){
int n = s.length();
boolean[][] dp = new boolean[n][n];
int maxLen = 1;
int begin = 0;
if(n < 2){
return n;
}
for(int i = 0; i < n; i++){
dp[i][i] = true;
}
for(int j = 1; j < n; j++){
for(int i = 0; i < n; i++){
if(s.charAt(i) == s.charAt(j)){
if(j - i < 3){
dp[i][j] = true;
}else{
dp[i][j] = dp[i+1][j-1];
}
}
if(dp[i][j] && j - i + 1 > maxLen){
maxLen = j -i + 1;
begin = i;
}
}
}
return maxLen;
}
}7-14 古风排版
中国的古人写文字，是从右向左竖向排版的。本题就请你编写程序，把一段文字按古风排版。
输入格式：
输入在第一行给出一个正整数N（<100），是每一列的字符数。第二行给出一个长度不超过1000的非空字符串，以回车结束。
输出格式：
按古风格式排版给定的字符串，每列N个字符（除了最后一列可能不足N个）。
输入样例：
4
This is a test case
输出样例：
asa T
st ih
e tsi
ce simport java.util.*;
public class Main{
public static void main(String[] args) {
Scanner reader=new Scanner(System.in);
int n= Integer.parseInt(reader.nextLine());
String a= reader.nextLine();
while(a.length()%n!=0)
{ a=a+" ";}
int i,j;
for(i=a.length()-n;i<a.length();i++)
{for(j=i;j>=0;j=j-n)
System.out.print(a.charAt(j));
System.out.println();}
}
}
7-15 稳赢
大家应该都会玩“锤子剪刀布”的游戏：两人同时给出手势，胜负规则如图所示：
现要求你编写一个稳赢不输的程序，根据对方的出招，给出对应的赢招。但是！为了不让对方输得太惨，你需要每隔K次就让一个平局。
输入格式：
输入首先在第一行给出正整数K（≤10），即平局间隔的次数。随后每行给出对方的一次出招：ChuiZi代表“锤子”、JianDao代表“剪刀”、Bu代表“布”。End代表输入结束，这一行不要作为出招处理。
输出格式：
对每一个输入的出招，按要求输出稳赢或平局的招式。每招占一行。
输入样例：
2
ChuiZi
JianDao
Bu
JianDao
Bu
ChuiZi
ChuiZi
End
输出样例：
Bu
ChuiZi
Bu
ChuiZi
JianDao
ChuiZi
Bu
import java.io.*;
public class Main {
public static void main(String[] args) throws IOException {
// 使用BufferedReader代替Scanner
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(reader.readLine());
String a;
int count = 1;
do {
a = reader.readLine();
// 使用switch语句减少比较次数
switch (a) {
case "ChuiZi":
if (count % (n + 1) != 0) {
System.out.println("Bu");
} else {
System.out.println("ChuiZi");
}
break;
case "Bu":
if (count % (n + 1) != 0) {
System.out.println("JianDao");
} else {
System.out.println("Bu");
}
break;
case "JianDao":
if (count % (n + 1) != 0) {
System.out.println("ChuiZi");
} else {
System.out.println("JianDao");
}
break;
case "End":
// 如果输入是"End"，则退出循环
break;
}
count++;
} while (!a.equals("End"));
reader.close();
}
}7-16 整除光棍
这里所谓的“光棍”，并不是指单身汪啦~ 说的是全部由1组成的数字，比如1、11、111、1111等。传说任何一个光棍都能被一个不以5结尾的奇数整除。比如，111111就可以被13整除。 现在，你的程序要读入一个整数x，这个整数一定是奇数并且不以5结尾。然后，经过计算，输出两个数字：第一个数字s，表示x乘以s是一个光棍，第二个数字n是这个光棍的位数。这样的解当然不是唯一的,题目要求你输出最小的解。
提示：一个显然的办法是逐渐增加光棍的位数，直到可以整除x为止。但难点在于，s可能是个非常大的数 —— 比如，程序输入31，那么就输出3584229390681和15，因为31乘以3584229390681的结果是111111111111111，一共15个1。
输入格式：
输入在一行中给出一个不以5结尾的正奇数x（<1000）。
输出格式：
在一行中输出相应的最小的s和n，其间以1个空格分隔。
输入样例：
31
输出样例：
3584229390681 15import java.util.*;
public class Main{
public static void main(String[]args){
Scanner reader=new Scanner(System.in);
int x = Integer.parseInt(reader.nextLine());
int s = 0, cnt = 0;
// 这一步的目的是避免s<x时s/x的结果为0
while (s < x) {
s = s * 10 + 1;
cnt++;
}
int i;
// 逐渐增加光棍的位数，直到可以整除x为止
for (i = cnt;; i++) {
System.out.print(s / x);
if (s % x == 0) {
break;
}
// 模拟除法取余数
s = s % x;
// 除数是由"1"组成的数，因此借位下来的也是"1"，即余数连接“1”的形式
s = s * 10 + 1;
}
System.out.println(" " + i);
}
}
7-17 矩阵A乘以B
给定两个矩阵A和B，要求你计算它们的乘积矩阵AB。需要注意的是，只有规模匹配的矩阵才可以相乘。即若A有Ra行、Ca列，B有Rb行、Cb列，则只有Ca与Rb相等时，两个矩阵才能相乘。
输入格式：
输入先后给出两个矩阵A和B。对于每个矩阵，首先在一行中给出其行数R和列数C，随后R行，每行给出C个整数，以1个空格分隔，且行首尾没有多余的空格。输入保证两个矩阵的R和C都是正数，并且所有整数的绝对值不超过100。
输出格式：
若输入的两个矩阵的规模是匹配的，则按照输入的格式输出乘积矩阵AB，否则输出Error: Ca != Rb，其中Ca是A的列数，Rb是B的行数。
输入样例1：
2 3
1 2 3
4 5 6
3 4
7 8 9 0
-1 -2 -3 -4
5 6 7 8
输出样例1：
2 4
20 22 24 16
53 58 63 28
输入样例2：
3 2
38 26
43 -5
0 17
3 2
-11 57
99 68
81 72
输出样例2：
Error: 2 != 3
import java.util.*;
public class Main{
public static void main(String[]args){
Scanner reader=new Scanner(System.in);
int m= reader.nextInt();
int n= reader.nextInt();
int [][]a=new int[m][n];
int i,j;
for(i=0;i<m;i++)
for(j=0;j<n;j++)
a[i][j]= reader.nextInt();
int p= reader.nextInt();
int q= reader.nextInt();
int [][]b=new int[p][q];
for(i=0;i<p;i++)
for(j=0;j<q;j++) {
b[i][j]= reader.nextInt();
}
if(n!=p)
System.out.printf("Error: %d != %d",n,p);
else {
System.out.printf("%d %d\n",m,q);
int[][] c = new int[m][q];
for (i = 0; i < m; i++) {
for (j = 0; j < q; j++) {
for (int k = 0; k < p; k++) {
c[i][j] += a[i][k] * b[k][j];
}
}
}
for (i = 0; i < m; i++) {
for (j = 0; j < q; j++) {
if (j != q - 1)
System.out.printf("%d ", c[i][j]);
else
System.out.printf("%d", c[i][j]);
}
System.out.println();
}
}
}
}7-18 倒数第N个字符串
给定一个完全由小写英文字母组成的字符串等差递增序列，该序列中的每个字符串的长度固定为 L，从 L 个 a 开始，以 1 为步长递增。例如当 L 为 3 时，序列为 { aaa, aab, aac, ..., aaz, aba, abb, ..., abz, ..., zzz }。这个序列的倒数第27个字符串就是 zyz。对于任意给定的 L，本题要求你给出对应序列倒数第 N 个字符串。
输入格式：
输入在一行中给出两个正整数 L（2 ≤ L ≤ 6）和 N（≤105）。
输出格式：
在一行中输出对应序列倒数第 N 个字符串。题目保证这个字符串是存在的。
输入样例：
3 7417
输出样例：
patimport java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int l = scanner.nextInt();
int n = scanner.nextInt();
int[] xx = new int[l];
int t = (int) Math.pow(26, l) - n;
for (int i = 0; i < l; i++) {
xx[i] = t % 26;
t /= 26;
}
for (int i = l - 1; i >= 0; i--) {
System.out.print((char) ('a' + xx[i])); // 输出对应的字符
}
scanner.close();
}
}
7-19 福到了
“福”字倒着贴，寓意“福到”。不论到底算不算民俗，本题且请你编写程序，把各种汉字倒过来输出。这里要处理的每个汉字是由一个 N × N 的网格组成的，网格中的元素或者为字符 @ 或者为空格。而倒过来的汉字所用的字符由裁判指定。
输入格式：
输入在第一行中给出倒过来的汉字所用的字符、以及网格的规模 N （不超过100的正整数），其间以 1 个空格分隔；随后 N 行，每行给出 N 个字符，或者为 @ 或者为空格。
输出格式：
输出倒置的网格，如样例所示。但是，如果这个字正过来倒过去是一样的，就先输出bu yong dao le，然后再用输入指定的字符将其输出。
输入样例 1：
$ 9
@ @@@@@
@@@ @@@
@ @ @
@@@ @@@
@@@ @@@@@
@@@ @ @ @
@@@ @@@@@
@ @ @ @
@ @@@@@
输出样例 1：
$$$$$ $
$ $ $ $
$$$$$ $$$
$ $ $ $$$
$$$$$ $$$
$$$ $$$
$ $ $
$$$ $$$
$$$$$ $
输入样例 2：
& 3
@@@
@
@@@
输出样例 2：
bu yong dao le
&&&
&
&&&import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
String x = reader.next();
int n = reader.nextInt();
reader.nextLine();
int i, j;
String[] a = new String[n];
for (i = 0; i < n; i++) {
a[i] = reader.nextLine();
}
boolean f = true;
for (i = 0; i < n; i++)
for (j = 0; j <= i; j++)
if (a[i].charAt(j) != a[n - i - 1].charAt(n - j - 1))
f = false;
if (f) {
System.out.println("bu yong dao le");
}
for(i=n-1;i>=0;i--) {
for (j = n - 1; j >= 0; j--) {
if (a[i].charAt(j) != ' ')
System.out.printf("%s", x);
else
System.out.print(' ');
}
System.out.println();
}
}
}7-20 猜数字
一群人坐在一起，每人猜一个 100 以内的数，谁的数字最接近大家平均数的一半就赢。本题就要求你找出其中的赢家。
输入格式：
输入在第一行给出一个正整数N（≤104）。随后 N 行，每行给出一个玩家的名字（由不超过8个英文字母组成的字符串）和其猜的正整数（≤ 100）。
输出格式：
在一行中顺序输出：大家平均数的一半（只输出整数部分）、赢家的名字，其间以空格分隔。题目保证赢家是唯一的。
输入样例：
7
Bob 35
Amy 28
James 98
Alice 11
Jack 45
Smith 33
Chris 62
输出样例：
22 Amy
import java.util.*;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner reader=new Scanner(System.in);
int n=Integer.parseInt(reader.nextLine());
String a[]=new String [n];
int []b=new int[n];
int i,sum=0;
for(i=0;i<n;i++)
{
a[i]=reader.next();
b[i]=Integer.parseInt(reader.next());
sum=sum+b[i];
}
double c[]=new double[n];
int average=sum/n/2;
System.out.print(average);
for(i=0;i<n;i++)
c[i]=Math.abs(b[i]-average);
int min=0;
for(i=1;i<c.length;i++)
{if(c[min]>c[i])
min=i;
}
System.out.printf(" %s",a[min]);
}
}
7-21 海盗分赃
P 个海盗偷了 D 颗钻石后来到公海分赃，一致同意如下分赃策略：
首先，P 个海盗通过抽签决定 1 - P 的序号。然后由第 1 号海盗提出一个分配方案（方案应给出每个海盗分得的具体数量），如果能够得到包括 1 号在内的绝对多数（即大于半数）同意，则按照该分配方案执行，否则 1 号将被投入大海喂鲨鱼；而后依次类似地由第 2 号、第 3 号等等海盗提出方案，直到能够获得绝对多数同意的方案出现为止，或者只剩下最后一位海盗，其独占所有钻石。请编写一个程序，给出第 1 号海盗的钻石分配方案中自己分得的钻石数量。
附带的三个假定：
- “聪明”与“贪婪”假定：每个海盗总能够以本人利益最大化作为行为准则；
- “人性化”假定：在能够取得尽量多钻石的情况下，海盗不会故意致同伙于死地；
- “无偏见”假定：海盗之间没有个人恩怨，分给其他海盗钻石的次序以小序号优先为原则。
输入格式：
输入在一行中给出 2 个正整数 D 和 P（3≤P≤D≤100）。
输出格式：
输出第 1 号海盗的钻石分配方案中自己分得的钻石数量。
输入样例：
10 7
输出样例：
6import java.util.*;
public class Main{
public static void main(String[]args){
Scanner reader=new Scanner(System.in);
int d=reader.nextInt();
int p=reader.nextInt();
int ans=0;
if(p==3)
ans = d-1 ;
else
ans = d-p/2-1;
System.out.print(ans);
}}
7-22 用扑克牌计算24点
一副扑克牌的每张牌表示一个数（J、Q、K 分别表示 11、12、13，两个司令都表示 6）。任取4 张牌，即得到 4 个 1~13 的数，请添加运算符（规定为加+ 减- 乘* 除/ 四种）使之成为一个运算式。每个数只能参与一次运算，4 个数顺序可以任意组合，4 个运算符任意取 3 个且可以重复取。运算遵从一定优先级别，可加括号控制，最终使运算结果为 24。请输出一种解决方案的表达式，用括号表示运算优先。如果没有一种解决方案，则输出 -1 表示无解。
输入格式：
输入在一行中给出 4 个整数，每个整数取值在 [1, 13]。
输出格式：
输出任一种解决方案的表达式，用括号表示运算优先。如果没有解决方案，请输出 -1。
输入样例：
2 3 12 12
输出样例：
((3-2)*12)+12特别注意以下是通过C语言代码实现的
#include<stdio.h>
/*接受两数和对应的算术符号，然后返回两数处理后的值*/
float operation(float a,float b,char c)
{
float sum=0;
switch(c)
{
case '+':
sum=a+b;
break;
case '-':
sum=a-b;
break;
case '*':
sum=a*b;
break;
case '/':
sum=a/b;
break;
}
return sum;
}
/*每次用一种符号表达式与24种排列做运算*/
int number(char* a,float*num)
{
float t1=0;
float t2=0;
float sum=0;
int i,j,k,l;
for(i=0;i<4;++i)
for(j=0;j<4;++j)
for(k=0;k<4;++k)
for(l=0;l<4;++l)
if( i!=j && i!=k && i!=l && j!=k && j!=l && k!=l )
{
/*((3-2)x12)+12形式*/
t1=operation(num[i],num[j],*a);
t2=operation(t1,num[k],*(a+1));
sum=operation(t2,num[l],*(a+2));
if(sum==24)
{
printf("((%.0f%c%.0f)%c%.0f)%c%.0f",num[i],*a,num[j],*(a+1),num[k],*(a+2),num[l]);
return 1;
}
/*(3-(2x12))+12形式*/
t1=operation(num[j],num[k],*(a+1));
t2=operation(num[i],t1,*a);
sum=operation(t2,num[l],*(a+2));
if(sum==24)
{
printf("(%.0f%c(%.0f%c%.0f))%c%.0f",num[i],*a,num[j],*(a+1),num[k],*(a+2),num[l]);
return 1;
}
/*(3-2)x(12+12)形式*/
t1=operation(num[i],num[j],*a);
t2=operation(num[k],num[l],*(a+2));
sum=operation(t1,t2,*(a+1));
if(sum==24)
{
printf("(%.0f%c%.0f)%c(%.0f%c%.0f)",num[i],*a,num[j],*(a+1),num[k],*(a+2),num[l]);
return 1;
}
/*3-(2*(12+12))形式*/
t1=operation(num[k],num[l],*(a+2));
t2=operation(num[j],t1,*(a+1));
sum=operation(num[i],t2,*a);
if(sum==24)
{
printf("%.0f%c(%.0f%c(%.0f%c%.0f))",num[i],*a,num[j],*(a+1),num[k],*(a+2),num[l]);
return 1;
}
/*3-((2*12)+12)*/
t1=operation(num[j],num[k],*(a+1));
t2=operation(t1,num[l],*(a+2));
sum=operation(num[i],t2,*a);
if(sum==24)
{
printf("%.0f%c((%.0f%c%.0f)%c%.0f)",num[i],*a,num[j],*(a+1),num[k],*(a+2),num[l]);
return 1;
}
}
return 0;
}
int main(void)
{
char a[6]="+-*/";
char b[64][5]={0};
float num[4]={0};
int i=0,j=0,k=0,l=0,m=0;
int count=0;
for(i=0;i<4;++i)
scanf("%f",&num[i]);
for(i=0;i<4;++i)
for(j=0;j<4;++j)
for(k=0;k<4;++k)
{
/*b数组存放64种符号表达式*/
b[l][m]=a[i];
b[l][m+1]=a[j];
b[l][m+2]=a[k];
++l;
}
for(i=0;i<64;++i)
if(number(b[i],num))/*等于24，输出并终止程序*/
return 0;
printf("-1");
return 0;
}
7-23 汉诺（Hanoi）塔问题
古代某寺庙中有一个梵塔，塔内有3个座A、B和C，座A上放着64个大小不等的盘，其中大盘在下，小盘在上。有一个和尚想把这64 个盘从座A搬到座B，但一次只能搬一个盘，搬动的盘只允许放在其他两个座上，且大盘不能压在小盘上。现要求用程序模拟该过程，输入一个正整数n，代表盘子的个数，编写函数
void hanoi(int n,char a,char b,char c)
其中，n为盘子个数，从a座到b座，c座作为中间过渡，该函数的功能是输出搬盘子的路径。
输入格式:
输入在一行中给出1个正整数n。
输出格式:
输出搬动盘子路径。
输入样例:
3
输出样例:
a-->b
a-->c
b-->c
a-->b
c-->a
c-->b
a-->bimport java.util.*;
public class Main{
// 汉诺塔递归函数
public static void hanoi(int n, char a, char b, char c) {
if (n == 1) {
System.out.println(a + "-->" + b);
} else {
hanoi(n - 1, a, c, b);
System.out.println(a + "-->" + b);
hanoi(n - 1, c, b, a);
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n;
n = scanner.nextInt();
char a = 'a', b = 'b', c = 'c';
hanoi(n, a, b, c);
}
}
7-24 6翻了
“666”是一种网络用语，大概是表示某人很厉害、我们很佩服的意思。最近又衍生出另一个数字“9”，意思是“6翻了”，实在太厉害的意思。如果你以为这就是厉害的最高境界，那就错啦 —— 目前的最高境界是数字“27”，因为这是 3 个 “9”！
本题就请你编写程序，将那些过时的、只会用一连串“6666……6”表达仰慕的句子，翻译成最新的高级表达。
输入格式：
输入在一行中给出一句话，即一个非空字符串，由不超过 1000 个英文字母、数字和空格组成，以回车结束。
输出格式：
从左到右扫描输入的句子：如果句子中有超过 3 个连续的 6，则将这串连续的 6 替换成 9；但如果有超过 9 个连续的 6，则将这串连续的 6 替换成 27。其他内容不受影响，原样输出。
输入样例：
it is so 666 really 6666 what else can I say 6666666666
输出样例：
it is so 666 really 9 what else can I say 27import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String input = scanner.nextLine();
String output = translateExpression(input);
System.out.println(output);
}
private static String translateExpression(String input) {
// 首先替换超过9个连续的6
input = input.replaceAll("6{10,}", "27");
// 然后替换4到9个连续的6
return input.replaceAll("6{4,9}", "9");
}
}
7-25 敲笨钟
微博上有个自称“大笨钟V”的家伙，每天敲钟催促码农们爱惜身体早点睡觉。为了增加敲钟的趣味性，还会糟改几句古诗词。其糟改的方法为：去网上搜寻压“ong”韵的古诗词，把句尾的三个字换成“敲笨钟”。例如唐代诗人李贺有名句曰：“寻章摘句老雕虫，晓月当帘挂玉弓”，其中“虫”（chong）和“弓”（gong）都压了“ong”韵。于是这句诗就被糟改为“寻章摘句老雕虫，晓月当帘敲笨钟”。
现在给你一大堆古诗词句，要求你写个程序自动将压“ong”韵的句子糟改成“敲笨钟”。
输入格式：
输入首先在第一行给出一个不超过 20 的正整数 N。随后 N 行，每行用汉语拼音给出一句古诗词，分上下两半句，用逗号 , 分隔，句号 . 结尾。相邻两字的拼音之间用一个空格分隔。题目保证每个字的拼音不超过 6 个字符，每行字符的总长度不超过 100，并且下半句诗至少有 3 个字。
输出格式：
对每一行诗句，判断其是否压“ong”韵。即上下两句末尾的字都是“ong”结尾。如果是压此韵的，就按题面方法糟改之后输出，输出格式同输入；否则输出 Skipped，即跳过此句。
输入样例：
5
xun zhang zhai ju lao diao chong, xiao yue dang lian gua yu gong.
tian sheng wo cai bi you yong, qian jin san jin huan fu lai.
xue zhui rou zhi leng wei rong, an xiao chen jing shu wei long.
zuo ye xing chen zuo ye feng, hua lou xi pan gui tang dong.
ren xian gui hua luo, ye jing chun shan kong.
输出样例：
xun zhang zhai ju lao diao chong, xiao yue dang lian qiao ben zhong.
Skipped
xue zhui rou zhi leng wei rong, an xiao chen jing qiao ben zhong.
Skipped
Skippedimport java.util.*;
public class Main{
public static void main(String[]args){
Scanner reader=new Scanner(System.in);
int n=Integer.parseInt(reader.nextLine());
int i,j;
for(i=0;i<n;i++)
{
String []a= reader.nextLine().trim().split(",");
if(a[0].endsWith("ong")&&a[1].endsWith("ong.")) {
String []t=a[1].split(" ");
t[t.length-3]="qiao";
t[t.length-2]="ben";
t[t.length-1]="zhong.";
System.out.printf("%s,", a[0]);
for(j=0;j<t.length;j++)
if(j!=0)
System.out.printf(" %s",t[j]);
else
System.out.printf("%s",t[j]);
System.out.println();
}
else
System.out.println("Skipped");
}
}
}
7-26 估值一亿的AI核心代码
以上图片来自新浪微博。
本题要求你实现一个稍微更值钱一点的 AI 英文问答程序，规则是：
- 无论用户说什么，首先把对方说的话在一行中原样打印出来；
- 消除原文中多余空格：把相邻单词间的多个空格换成 1 个空格，把行首尾的空格全部删掉，把标点符号前面的空格删掉；
- 把原文中所有大写英文字母变成小写，除了
I； - 把原文中所有独立的
can you、could you对应地换成I can、I could—— 这里“独立”是指被空格或标点符号分隔开的单词； - 把原文中所有独立的
I和me换成you； - 把原文中所有的问号
?换成惊叹号!； - 在一行中输出替换后的句子作为 AI 的回答。
输入格式：
输入首先在第一行给出不超过 10 的正整数 N，随后 N 行，每行给出一句不超过 1000 个字符的、以回车结尾的用户的对话，对话为非空字符串，仅包括字母、数字、空格、可见的半角标点符号。
输出格式：
按题面要求输出，每个 AI 的回答前要加上 AI: 和一个空格。
输入样例：
6
Hello ?
Good to chat with you
can you speak Chinese?
Really?
Could you show me 5
What Is this prime? I,don 't know
输出样例：
Hello ?
AI: hello!
Good to chat with you
AI: good to chat with you
can you speak Chinese?
AI: I can speak chinese!
Really?
AI: really!
Could you show me 5
AI: I could show you 5
What Is this prime? I,don 't know
AI: what Is this prime! you,don't knowimport java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
String str;
int n=Integer.parseInt(in.nextLine());
for(int i=0;i<n;i++) {
str=in.nextLine();
System.out.println(str);
String cstr="";
char[] chars=str.toCharArray();
for(int j=0;j<chars.length;j++)
{
if(chars[j]>='A'&&chars[j]<='Z'&&chars[j]!='I') {
chars[j]+=32;
}
cstr+=chars[j];
}
cstr=cstr.trim();//去掉首尾多余空格
cstr=cstr.replaceAll(" +", " ");
cstr=cstr.replaceAll(" (\\W)", "$1");
cstr=cstr.replaceAll("\\?", "!");
cstr=cstr.replaceAll("\\bcan you\\b","A");
cstr=cstr.replaceAll("\\bcould you\\b","B");
cstr=cstr.replaceAll("\\b(I|me)\\b","C");
cstr=cstr.replaceAll("A","I can");
cstr=cstr.replaceAll("B","I could");
cstr=cstr.replaceAll("C","you");
System.out.println("AI: "+cstr);
}
}
}
以上就是关于综合训练四的答案了，欢迎大家借鉴！
扫一扫
1056
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
