36：字符串加密
总时间限制：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) {
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;
}
}37：Problem N：矩阵交换行
总时间限制：1000ms 内存限制：65536kb
描述
编写一个函数，输入参数是5*5的二维数组，和n，m两个行下标。功能：判断n，m是否在数组范围内，如果不在，则返回0；如果在范围内，则将n行和m行交换，并返回1。
在main函数中， 生成一个5*5的矩阵，输入矩阵数据，并输入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
代码：
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)) {//行列为5
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();
}
}
}
}38：求字符串长度
总时间限制：1000ms 内存限制：65536kb
描述
求一个长度不大于100的字符串的长度，要求不使用strlen方法，并且使用到字符指针。
输入
输出
字符串的长度
样例输入
I love Beijing.
样例输出
15
代码：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println(sc.nextLine().length());
}
}nextLine：
以enter为结束符，也就是说nextLine()方法返回的是输入回车之前所有的字符，可以获得空白
39：计算反序数
总时间限制：1000ms 内存限制：65536kb
描述
编写函数，参数为一个整数，返回这个整数的反序数，例如参数是1576，返回一个整数6751，如果输入时1230，则返回321。在main函数中调用此函数，并将结果输出。
输入
一个整数
输出
反序数
样例输入
0
123
100
-23
-0
-100
样例输出
0
321
1
-32
0
-1
代码：
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()==true) {//检查是否有非空字符
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);
}
}
}
}40：最大正相匹配
总时间限制：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;
}
}
}
}
}
}41：循环移动
总时间限制：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+" ");
}
}
}42：约瑟夫问题
总时间限制：1000ms 内存限制：65536kb
描述
约瑟夫问题：有ｎ只猴子，按顺时针方向围成一圈选大王（编号从１到ｎ），从第１号开始报数，一直数到ｍ，数到ｍ的猴子退出圈外，剩下的猴子再接着从1开始报数。就这样，直到圈内只剩下一只猴子时，这个猴子就是猴王，编程求输入ｎ，ｍ后，输出最后猴王的编号。
输入
每行是用空格分开的两个整数，第一个是 n, 第二个是 m ( 0 < m,n <=300)。最后一行是：
0 0
输出
对于每行输入数据（最后一行除外)，输出数据也是一行，即最后猴王的编号
样例输入
6 2
12 4
8 3
0 0
样例输出
51
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));
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
