【Java】练习题（4）
31:优美字符串
总时间限制: 1000ms 内存限制: 65536kB
描述
对于给定的两个字符串，我们将要做的是将它们拼接起来，拼接成一个“优美”的字符串，那么什么样的字符串是优美的呢？举一个例子，我们要求拼接时，第一个字符串ABCE在前，第二个字符串CEDF在后，拼接的结果是ABCECEDF，接着，我们要对这个ABCECEDF进行修饰，要求将它们在连接处相同的子串重叠在一起，重叠之后的结果为ABCEDF,这就是拼接形成的优美的字符串，现在请你完成这个任务。
输入
输入包含两个用空格隔开的字符串s1和s2
输出
输出一个字符串，表示拼接之后的“优美字符串”
样例输入
ABB ABB
样例输出
ABB
提示
s1和s2的长度 1≤L≤1000
代码
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s1 = sc.next();
String s2 = sc.next();
for(int i=s2.length();i>=0;i--){
String ts1 = s2.substring(0, i);
if (s1.endsWith(ts1)) {
System.out.println(s1.concat(s2.substring(i)));
return;
}
}
}
}
32:小白鼠再排队
总时间限制: 1000ms 内存限制: 65536kB
描述
N只小白鼠(1 < N < 100)，每只鼠头上戴着一顶有颜色的帽子。现在称出每只白鼠的重量，要求按照白鼠重量从小到大的顺序输出它们头上帽子的颜色。帽子的颜色用 “red”，“blue”等字符串来表示。不同的小白鼠可以戴相同颜色的帽子。白鼠的重量用整数表示。
输入
输入第一行为一个整数N，表示小白鼠的数目。
下面有N行，每行是一只白鼠的信息。第一个为正整数，表示白鼠的重量，；第二个为字符串，表示白鼠的帽子颜色，字符串长度不超过10个字符。
注意：白鼠的重量各不相同。
输出
按照白鼠的重量从小到大的顺序输出白鼠的帽子颜色。
样例输入
3
30 red
50 blue
40 green
样例输出
red
green
blue
代码
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
Mouse[] ms = new Mouse[n];
for (int i = 0; i < n; i++) {
ms[i] = new Mouse(sc.nextInt(), sc.next());
}
Arrays.sort(ms, (m1, m2) -> m1.weight - m2.weight);
for (Mouse m : ms) {
System.out.println(m.color);
}
}
}
class Mouse {
int weight;
String color;
public Mouse(int weight, String color) {
super();
this.weight = weight;
this.color = color;
}
}
33:中位数
总时间限制: 2000ms 内存限制: 65536kB
描述
中位数定义：一组数据按从小到大的顺序依次排列，处在中间位置的一个数或最中间两个数据的平均值（如果这组数的个数为奇数，则中位数为位于中间位置的那个数；如果这组数的个数为偶数，则中位数是位于中间位置的两个数的平均值）.
给出一组无序整数，求出中位数，如果求最中间两个数的平均数，向下取整即可（不需要使用浮点数）
输入
该程序包含多组测试数据，每一组测试数据的第一行为N，代表该组测试数据包含的数据个数，1 <= N <= 15000.
接着N行为N个数据的输入，N=0时结束输入
输出
输出中位数，每一组测试数据输出一行
样例输入
4
10
30
20
40
3
40
30
50
4
1
2
3
4
0
样例输出
25
40
2
代码
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
while(true){
int n=sc.nextInt();
if(n==0){
break;
}
int[] sz=new int[n];
for(int i=0;i<n;i++){
sz[i]=sc.nextInt();
}
Arrays.sort(sz);
if(n%2==0){
int t1=n/2;
System.out.println((sz[t1]+sz[t1-1])/2);
}
else{
System.out.println(sz[(n-1)/2]);
}
}
}
}
34:字符串加密
总时间限制: 1000ms 内存限制: 65536kB
描述
现要对一个由大写字母组成的字符串进行加密，有两种加密方法
(1)替换法：把一个字母替换成它之后的第k个字母，比如AXZ，k取2，加密后得到CZB(Z之后第二个字符为B)
(2)置换法：改变原来字符串中字母的顺序，比如将顺序<2 3 1>应用到ABC上得到的密文为BCA。(顺序<2 3 1>指将原字符串的第2个字符作为新字符串的第1个字符，将原字符串的第3个字符作为新字符串的第2个字符，以此类推)
这两种方法单独使用都很容易被人破解，所以我们将两种方法联合使用，对一个字符串进行两次加密，比如AXZ在k=2和顺序<2 3 1>下加密得到ZBC。
输入
包含若干组数据，每组数据一行。一组数据由三部分组成：待加密的字符串(长度不超过30)、k、顺序。
输出
对于每组数据输出一行，为加密后的字符串.
样例输入
AXZ 2 2 3 1
VICTORIOUS 1 2 1 5 4 3 7 6 10 9 8
样例输出
ZBC
JWPUDJSTVP
代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String s=sc.next();
int len=s.length();
int pos=sc.nextInt();
int[] a=new int[len];
for(int i=0;i<len;i++){
a[i]=sc.nextInt();
}
char[] sz=s.toCharArray();
for(int i=0;i<len;i++){
sz[i]=zh1(sz[i],pos);
}
for(int i=0;i<len;i++){
System.out.print(sz[a[i]-1]);;
}
System.out.println();
}
}
static char zh1(char c,int pos){
int asc=c;
pos=pos%26;
asc=asc+pos;
if(asc>90){
asc-=26;
}
return (char)asc;
}
}
35:Problem N:矩阵交换行
总时间限制: 1000ms 内存限制: 65536kB
描述
编写一个函数，输入参数是55的二维数组，和n，m两个行下标。功能：判断n，m是否在数组范围内，如果不在，则返回0；如果在范围内，则将n行和m行交换，并返回1。
在main函数中， 生成一个55的矩阵，输入矩阵数据，并输入n，m的值。调用前面的函数。如果返回值为0，输出error。如果返回值为1，输出交换n，m后的新矩阵。
输入
5*5矩阵的数据，以及n和m的值。
输出
如果不可交换，则输出error；
如果可交换，则输出新矩阵
样例输入
1 2 2 1 2
5 6 7 8 3
9 3 0 5 3
7 2 1 4 6
3 0 8 2 4
0 4
样例输出
3 0 8 2 4
5 6 7 8 3
9 3 0 5 3
7 2 1 4 6
1 2 2 1 2
提示
不需要用while循环来反复读取文件中的测试集。
输出error格式如下：
cout<< “error” << endl;
输出矩阵格式如下：
cout<< setw(4)<< num;
输出矩阵一行后要输出cout<< endl;
代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[][] a = new int[5][5];
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
a[i][j] = sc.nextInt();
}
}
int m = sc.nextInt();
int n = sc.nextInt();
if (!(m >= 0 && m <= 4 && n >= 0 && n <= 4)) {
System.out.println("error");
} else {
for (int k = 0; k < 5; k++) {
int temp = a[m][k];
a[m][k] = a[n][k];
a[n][k] = temp;
}
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
System.out.printf("%4d", a[i][j]);
}
System.out.println();
}
}
}
}
36:求字符串长度
总时间限制: 1000ms 内存限制: 65536kB
描述
求一个长度不大于100的字符串的长度，要求不使用strlen方法，并且使用到字符指针。
输入
字符串
输出
字符串的长度。
样例输入
I love Beijing.
样例输出
15
代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
System.out.println(sc.nextLine().length());
}
}
37:计算反序数
总时间限制: 1000ms 内存限制: 65536kB
描述
编写函数，参数为一个整数，返回这个整数的反序数，例如参数是1576，返回一个整数6751，如果输入时1230，则返回321。在main函数中调用此函数，并将结果输出。
输入
一个整数
输出
它的反序数
样例输入
0
123
100
-23
-0
-100
样例输出
0
321
1
-32
0
-1
提示
需要保留数字的符号.负数的反序数仍然是负数,正数的反序数不用添加符号.
要求以子函数的形式计算此反序数,子函数的形式为:
int reverse(int num);
输入不会超出int的大小.
因为有多组测试数据,读取输入的时候建议采用如下形式:
int i = 0;
while(cin>>i)
{
//你的代码
}
代码
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
boolean flag=false;
int n=sc.nextInt();
String ns=n+"";
if(ns.startsWith("-")){
flag=true;
ns=ns.substring(1);
}
int a=Integer.parseInt(new StringBuffer(ns).reverse().toString());
if(flag&&a!=0){
System.out.println("-"+a);
}
else{
System.out.println(a);
}
}
}
}
38:最大正向匹配
总时间限制: 1000ms 内存限制: 65536kB
描述
给定2个短字符串str1,str2，在一个长字符串中找出以str1开头并且以str2结尾的最长字符串。
输入
第1行为str1, 表是开头字符串
第2行为str2, 表示结尾字符串
第3行为一个整数，表示接下来将要输入的数据行数n
第4行以下为输入字符串
所有字符串小于1024长
输出
n行, 输出找到的字长字串,包括首尾
样例输入
ab
ba
3
aab11234ab56ba789baba
abababa
adsjjafshabbajafkalf
样例输出
ab11234ab56ba789baba
abababa
abba
提示
可以利用指针和字符串处理函数(算法)解题
代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String a = sc.next();
String b = sc.next();
int n = sc.nextInt();
sc.nextLine();
l1: for (int i = 0; i < n; i++) {
String s = sc.nextLine();
int len=s.length();
for(int j=len;j>=0;j--){
for(int k=0;k<=len-j;k++){
String t=s.substring(k,k+j);
if(t.startsWith(a)&&t.endsWith(b)){
System.out.println(t);
continue l1;
}
}
}
}
}
}
39:循环移动
总时间限制: 1000ms 内存限制: 65536kB
描述
给定一组整数，要求利用数组把这组数保存起来，再利用指针实现对数组中的数循环移动。假定共有n个整数，则要使前面各数顺序向后移m个位置，并使最后m各数变为最前面的m各数。
注意，不要用先输出后m个数，再输出前n-m个数的方法实现，也不要用两个数组的方式实现。
要求只用一个数组的方式实现，一定要保证在输出结果时，输出的顺序和数组中数的顺序是一致的。
输入
输入有两行：第一行包含一个正整数n和一个正整数m，第二行包含n个正整数。每两个正整数中间用一个空格分开。
输出
输出有一行：经过循环移动后数组中整数的顺序依次输出，每两个整数之间用空格分隔。
样例输入
11 4
15 3 76 67 84 87 13 67 45 34 45
样例输出
67 45 34 45 15 3 76 67 84 87 13
代码
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
List<Integer> list1=new LinkedList<Integer>();
for (int i = 0; i < a; i++) {
list1.add(sc.nextInt());
}
for (int i = 0; i < b; i++) {
list1.add(0,list1.remove(a-1));
}
for (Integer i : list1) {
System.out.print(i+" ");
}
}
}
40:约瑟夫问题
总时间限制: 1000ms 内存限制: 65536kB
描述
约瑟夫问题：有ｎ只猴子，按顺时针方向围成一圈选大王（编号从１到ｎ），从第１号开始报数，一直数到ｍ，数到ｍ的猴子退出圈外，剩下的猴子再接着从1开始报数。就这样，直到圈内只剩下一只猴子时，这个猴子就是猴王，编程求输入ｎ，ｍ后，输出最后猴王的编号。
输入
每行是用空格分开的两个整数，第一个是 n, 第二个是 m ( 0 < m,n <=300)。最后一行是：
0 0
输出
对于每行输入数据（最后一行除外)，输出数据也是一行，即最后猴王的编号
样例输入
6 2
12 4
8 3
0 0
样例输出
5
1
7
代码
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(true){
int m = sc.nextInt();
int n = sc.nextInt();
if(m==0&&n==0){
break;
}
List<Integer> list1=new LinkedList<Integer>();
for (int i = 1; i < m + 1; i++) {
list1.add(i);
}
for (int i = 0; i < m - 1; i++) {
for (int j = 0; j < n - 1; j++) {
list1.add(list1.remove(0));
}
list1.remove(0);
}
System.out.println(list1.get(0));
}
}
}