题目描述
写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。
输入描述:
输入一个十六进制的数值字符串。注意：一个用例会同时有多组输入数据，请参考帖子https://www.nowcoder.com/discuss/276处理多组输入的问题。
输出描述:
输出该数值的十进制字符串。不同组的测试用例用\n隔开。
示例1
输入
0xA 0xAA
输出
10 170
import java.util.*;
import java.io.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String input = sc.nextLine();
long l = Long.parseLong(input.substring(2), 16);
System.out.println(l);
}
}
}
题目描述
功能:输入一个正整数，按照从小到大的顺序输出它的所有质因子（重复的也要列举）（如180的质因子为2 2 3 3 5 ）
最后一个数后面也要有空格
输入描述:
输入一个long型整数
输出描述:
按照从小到大的顺序输出它的所有质数的因子，以空格隔开。最后一个数后面也要有空格。
示例1
输入
180
输出
2 2 3 3 5
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
long num = sc.nextLong();
System.out.println(getResult(num));
}
public static String getResult(long num){
int a = 2;
String result = "";
while(num != 1){
while(num%a ==0){
num = num / a;
result = result + a +" ";
}
a++;
}
return result;
}
}题目描述
数据表记录包含表索引和数值（int范围的整数），请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照key值升序进行输出。
输入描述:
先输入键值对的个数
然后输入成对的index和value值，以空格隔开
输出描述:
输出合并后的键值对（多行）
示例1
输入
4 0 1 0 2 1 2 3 4
输出
0 3 1 2 3 4
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line = null;
Map<Integer, Integer> map = new HashMap<>();
line = br.readLine();
int[] ints = new int[Integer.valueOf(line)];
while ((line =br.readLine()) !=null){
int a = line.indexOf(" ");
int b = line.indexOf(" ", a);
Integer c = Integer.valueOf(line.substring(0, a));
Integer d = Integer.valueOf(line.substring(a + 1));
ints[c] = ints[c]+d;
// if (map.containsKey(c)){
// map.put(c, map.get(c) + d);
// }else {
// map.put(c, d);
// }
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i <ints.length ; i++) {
if (ints[i]!=0){
sb.append(i).append(" ").append(ints[i]).append("\n");
}
}
sb.deleteCharAt(sb.length()-1);
System.out.println(sb.toString());
}
}题目描述
输入一个int型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
输入描述:
输入一个int型整数
输出描述:
按照从右向左的阅读顺序，返回一个不含重复数字的新的整数
示例1
输入
9876673
输出
37689
import java.io.InputStream;
public class Main {
public static void main(String[] args) throws Exception {
InputStream in = System.in;
int available = in.available()-1;
char[] chars = new char[available];
while (available-- > 0) {
chars[available] = (char) in.read();
}
StringBuilder resul = new StringBuilder();
for (int i = 0; i < chars.length; i++) {
if (resul.lastIndexOf(String.valueOf(chars[i])) != -1){
continue;
}
resul.append(chars[i]);
}
System.out.println(resul.toString());
}
}题目描述
编写一个函数，计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)，换行表示结束符，不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次
例如，对于字符串abaca而言，有a、b、c三种不同的字符，因此输出3。
输入描述:
输入N个字符，字符在ACSII码范围内。
输出描述:
输出范围在(0~127)字符的个数。
示例1
输入
复制
abc
输出
复制
3
import java.util.*;
import java.io.*;
public class Main{
public static void main(String[]args)throws Exception{
BufferedReader shuru = new BufferedReader(new InputStreamReader(System.in));
String s = shuru.readLine();
int[] a = new int[128];
int count=0;
for(int i=0;i<s.length();i++){
char b = s.charAt(i);
if(a[b]==0){
count++;
a[b]=1;
}
}
System.out.println(count);
}
}题目描述
输入一个整数，将这个整数以字符串的形式逆序输出
程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001
输入描述:
输入一个int整数
输出描述:
将这个整数以字符串的形式逆序输出
示例1
输入
复制
1516000
输出
复制
0006151
import java.io.InputStream;
public class Main{
public static void main(String[] args)throws Exception{
InputStream stream = System.in;
int l;
byte[] bytes = new byte[1024];
while((l = stream.read(bytes))>0){
String numStr = new String(bytes, 0, l - 1);
char [] numChars = numStr.toCharArray();
char [] numCharsConvert = new char[numChars.length];
for(int i =0; i < numChars.length; i++){
numCharsConvert[i] = numChars[numChars.length-1-i];
}
System.out.println(new String (numCharsConvert));
}
}
}题目描述
写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000）
输入描述:
输入N个字符
输出描述:
输出该字符串反转后的字符串
示例1
输入
复制
abcd
输出
复制
dcba
import java.io.*;
public class Main{
public static void main(String[] args) throws IOException{
InputStream in = System.in;
int len;
byte[] b = new byte[1024];
while((len = in.read(b)) > 0){
String str = new String(b,0,len-1);
char [] chars = str.toCharArray();
char [] charsFb = new char[chars.length];
for(int i = 0;i<chars.length;i++){
charsFb[i] = chars[chars.length -1 -i];
}
System.out.println(new String(charsFb));
}
}
}题目描述
给定n个字符串，请对n个字符串按照字典序排列。
输入描述:
输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。
输出描述:
数据输出n行，输出结果为按照字典序排列的字符串。
示例1
输入
复制
9 cap to cat card two too up boat boot
输出
复制
boat boot cap card cat to too two up
import java.util.*;
import java.io.*;
public class Main{
public static void main(String[] args) throws IOException{
BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
int count=Integer.parseInt(bf.readLine());
String[] result=new String[count];
for(int i=0;i<count;i++)result[i]=bf.readLine();
StringBuilder sb=new StringBuilder();
Arrays.sort(result);
for (String w : result) sb.append(w).append('\n');
System.out.println(sb.toString());
}
}题目描述
输入一个int型的正整数，计算出该int型数据在内存中存储时1的个数。
输入描述:
输入一个整数（int类型）
输出描述:
这个数转换成2进制后，输出1的个数
示例1
输入
复制
5
输出
复制
2
import java.io.InputStream;
public class Main {
public static void main(String[] args) throws Exception {
InputStream stream = System.in;
int l ;
byte[] bytes = new byte[1024];
while ((l = stream.read(bytes)) > 0) {
String numStr = new String(bytes, 0, l - 1);
int num = Integer.parseInt(numStr);
char [] numChars = Integer.toBinaryString(num).toCharArray();
int countNum = 0;
for (int i = 0;i < numChars.length; i++){
if (numChars[i] == '1'){
countNum = countNum + 1;
}
}
System.out.println(countNum);
}
}
}题目描述
王强今天很开心，公司发给N元的年终奖。王强决定把年终奖用于购物，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子：
| 主件 | 附件 |
| 电脑 | 打印机，扫描仪 |
| 书柜 | 图书 |
| 书桌 | 台灯，文具 |
| 工作椅 | 无 |
如果要买归类为附件的物品，必须先买该附件所属的主件。每个主件可以有 0 个、 1 个或 2 个附件。附件不再有从属于自己的附件。王强想买的东西很多，为了不超出预算，他把每件物品规定了一个重要度，分为 5 等：用整数 1 ~ 5 表示，第 5 等最重要。他还从因特网上查到了每件物品的价格（都是 10 元的整数倍）。他希望在不超过 N 元（可以等于 N 元）的前提下，使每件物品的价格与重要度的乘积的总和最大。
设第 j 件物品的价格为 v[j] ，重要度为 w[j] ，共选中了 k 件物品，编号依次为 j 1 ， j 2 ，……， j k ，则所求的总和为：
v[j 1 ]*w[j 1 ]+v[j 2 ]*w[j 2 ]+ … +v[j k ]*w[j k ] 。（其中 * 为乘号）
请你帮助王强设计一个满足要求的购物单
输入描述:
输入的第 1 行，为两个正整数，用一个空格隔开：N m
（其中 N （ <32000 ）表示总钱数， m （ <60 ）为希望购买物品的个数。）
从第 2 行到第 m+1 行，第 j 行给出了编号为 j-1 的物品的基本数据，每行有 3 个非负整数 v p q
（其中 v 表示该物品的价格（ v<10000 ）， p 表示该物品的重要度（ 1 ~ 5 ）， q 表示该物品是主件还是附件。如果 q=0 ，表示该物品为主件，如果 q>0 ，表示该物品为附件， q 是所属主件的编号）
输出描述:
输出文件只有一个正整数，为不超过总钱数的物品的价格与重要度乘积的总和的最大值（ <200000 ）。
示例1
输入
复制
1000 5 800 2 0 400 5 1 300 5 1 400 3 0 500 2 0
输出
复制
2200
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = br.readLine();
int N = Integer.parseInt(str.split(" ")[0])/10;
int m = Integer.parseInt(str.split(" ")[1]);
int[] v= new int[m+1];
int[] p= new int[m+1];
int[] q= new int[m+1];
boolean[] flags = new boolean[m+1];
int[][] res = new int[m+1][N+1];
for (int i = 1; i <= m; i++) {
String[] strings = br.readLine().split(" ");
v[i] = (Integer.parseInt(strings[0]))/10;
p[i] = Integer.parseInt(strings[1]) * v[i];
q[i] = Integer.parseInt(strings[2]);
}
for (int i = 1; i <= m; i++) {
for(int j = 1; j<=N; j++){
if(q[i] == 0) {
if(v[i] <= j){
res[i][j] = Math.max(res[i-1][j], res[i-1][j-v[i]] + p[i]);
}
}else{
if(v[i] + v[q[i]] <= j){
res[i][j] = Math.max(res[i-1][j], res[i-1][j-v[i]] + p[i]);
}
}
}
}
System.out.println(res[m][N] * 10);
}
}题目描述
开发一个坐标计算工具， A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。从（0,0）点开始移动，从输入字符串里面读取一些坐标，并将最终输入结果输出到输出文件里面。
输入：
合法坐标为A(或者D或者W或者S) + 数字（两位以内）
坐标之间以;分隔。
非法坐标点需要进行丢弃。如AA10; A1A; $%$; YAD; 等。
下面是一个简单的例子 如：
A10;S20;W10;D30;X;A1A;B10A11;;A10;
处理过程：
起点（0,0）
+ A10 = （-10,0）
+ S20 = (-10,-20)
+ W10 = (-10,-10)
+ D30 = (20,-10)
+ x = 无效
+ A1A = 无效
+ B10A11 = 无效
+ 一个空 不影响
+ A10 = (10,-10)
结果 （10， -10）
注意请处理多组输入输出
输入描述:
一行字符串
输出描述:
最终坐标，以逗号分隔
示例1
输入
复制
A10;S20;W10;D30;X;A1A;B10A11;;A10;
输出
复制
10,-10
import java.io.*;
public class Main{
public static void main(String[] args ) throws Exception{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s;
while((s = br.readLine()) != null){
String[] str = s.split(";");
int x = 0;
int y = 0;
for(int i = 0;i < str.length;i++){
int change = 0;
char[] cha = str[i].toCharArray();
for(int j = 1;j <cha.length;j++){
if(cha[j] >= '0' &&cha[j] <= '9'){
change = change*10 +(cha[j]-'0');
}else{
break;
}
}
switch (cha[0]){
case 'A' :
x -= change;
break;
case 'D' :
x += change;
break;
case 'S':
y -= change;
break;
case 'W':
y += change;
break;
}
}
System.out.println(x+","+y);
}
}
}题目描述
请解析IP地址和对应的掩码，进行分类识别。要求按照A/B/C/D/E类地址归类，不合法的地址和掩码单独归类。
所有的IP地址划分为 A,B,C,D,E五类
A类地址1.0.0.0~126.255.255.255;
B类地址128.0.0.0~191.255.255.255;
C类地址192.0.0.0~223.255.255.255;
D类地址224.0.0.0~239.255.255.255；
E类地址240.0.0.0~255.255.255.255
私网IP范围是：
10.0.0.0～10.255.255.255
172.16.0.0～172.31.255.255
192.168.0.0～192.168.255.255
子网掩码为二进制下前面是连续的1，然后全是0。（例如：255.255.255.32就是一个非法的掩码）
注意二进制下全是1或者全是0均为非法
注意：
1. 类似于【0.*.*.*】和【127.*.*.*】的IP地址不属于上述输入的任意一类，也不属于不合法ip地址，计数时可以忽略
2. 私有IP地址和A,B,C,D,E类地址是不冲突的
输入描述:
多行字符串。每行一个IP地址和掩码，用~隔开。
输出描述:
统计A、B、C、D、E、错误IP地址或错误掩码、私有IP的个数，之间以空格隔开。
示例1
输入
复制
10.70.44.68~255.254.255.0 1.0.0.1~255.0.0.0 192.168.0.2~255.255.255.0 19..0.~255.255.255.0
输出
复制
1 0 1 0 0 2 1
题目要点：
所有的IP地址划分为 A,B,C,D,E五类：
A类地址1.0.0.0 ~ 126.255.255.255;
B类地址128.0.0.0 ~ 191.255.255.255;
C类地址192.0.0.0 ~ 223.255.255.255;
D类地址224.0.0.0 ~ 239.255.255.255；
E类地址240.0.0.0 ~ 255.255.255.255
私网IP范围是：
10.0.0.0～10.255.255.255
172.16.0.0～172.31.255.255
192.168.0.0～192.168.255.255
子网掩码为二进制下前面是连续的1，然后全是0。
输出：统计A、B、C、D、E、错误IP地址或错误掩码、私有IP的个数
一些需要注意的细节
类似于【0.*.*.*】和【127.*.*.*】的IP地址不属于上述输入的任意一类，也不属于不合法ip地址，计数时可以忽略
私有IP地址和A,B,C,D,E类地址是不冲突的，也就是说需要同时+1
如果子网掩码是非法的，则不再需要查看IP地址
全零【0.0.0.0】或者全一【255.255.255.255】的子网掩码也是非法的
思路
按行读取输入，根据字符‘~’ 将IP地址与子网掩码分开
查看子网掩码是否合法。
合法，则继续检查IP地址
非法，则相应统计项+1，继续下一行的读入
查看IP地址是否合法
合法，查看IP地址属于哪一类，是否是私有ip地址；相应统计项+1
非法，相应统计项+1
具体实现
判断IP地址是否合法，如果满足下列条件之一即为非法地址
数字段数不为4
存在空段，即【192..1.0】这种
某个段的数字大于255
判断子网掩码是否合法，如果满足下列条件之一即为非法掩码
不是一个合格的IP地址
在二进制下，不满足前面连续是1，然后全是0
在二进制下，全为0或全为1
如何判断一个掩码地址是不是满足前面连续是1，然后全是0？
将掩码地址转换为32位无符号整型，假设这个数为b。如果此时b为0，则为非法掩码
将b按位取反后+1。如果此时b为1，则b原来是二进制全1，非法掩码
如果b和b-1做按位与运算后为0，则说明是合法掩码，否则为非法掩码import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main{
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int a = 0, b = 0, c = 0, d = 0, e = 0;
int err = 0;
int pri = 0;
String str;
String[] ip_mask;
String[] ip;
int i;
while ((str = br.readLine()) != null) {
ip_mask = str.split("~");
ip = ip_mask[0].split("\\.");
// count error mask
if (checkMask(ip_mask[1])) { // mask correct
// count ip
if (checkIP(ip)) {
i = Integer.parseInt(ip[0]);
if (i >= 1 && i <= 126) { // A
a++;
if (i == 10) {
pri++;
}
} else if (i >= 128 && i <= 191) { // B
b++;
if (i == 172 && Integer.parseInt(ip[1]) >= 16 && Integer.parseInt(ip[1]) <= 31) {
pri++;
}
} else if (i >= 192 && i <= 223) { // C
c++;
if (i == 192 && Integer.parseInt(ip[1]) == 168) {
pri++;
}
} else if (i >= 224 && i <= 239) { // D
d++;
} else if (i >= 240 && i <= 255) { // E
e++;
}
} else {
err++;
}
} else {
err++;
}
}
// output
System.out.println(a + " " + b + " " + c + " " + d + " " + e + " " + err + " " + pri);
}
private static boolean checkMask(String mask) {
// check mask
String[] mask_arr = mask.split("\\.");
if (mask_arr[0].equals("255")) {
if (mask_arr[1].equals("255")) {
if (mask_arr[2].equals("255")) {
return mask_arr[3].equals("254") || mask_arr[3].equals("252") || mask_arr[3].equals("248") ||
mask_arr[3].equals("240") || mask_arr[3].equals("224") || mask_arr[3].equals("192") ||
mask_arr[3].equals("128") || mask_arr[3].equals("0");
} else if (mask_arr[2].equals("254") || mask_arr[2].equals("252") || mask_arr[2].equals("248") ||
mask_arr[2].equals("240") || mask_arr[2].equals("224") || mask_arr[2].equals("192") ||
mask_arr[2].equals("128") || mask_arr[2].equals("0")) {
return mask_arr[3].equals("0");
} else
return false;
} else if (mask_arr[1].equals("254") || mask_arr[1].equals("252") || mask_arr[1].equals("248") ||
mask_arr[1].equals("240") || mask_arr[1].equals("224") || mask_arr[1].equals("192") ||
mask_arr[1].equals("128") || mask_arr[1].equals("0")) {
return mask_arr[2].equals("0") && mask_arr[3].equals("0");
} else {
return false;
}
} else if (mask_arr[0].equals("254") || mask_arr[0].equals("252") || mask_arr[0].equals("248") ||
mask_arr[0].equals("240") || mask_arr[0].equals("224") || mask_arr[0].equals("192") ||
mask_arr[0].equals("128") || mask_arr[0].equals("0")) {
return mask_arr[1].equals("0") && mask_arr[2].equals("0") && mask_arr[3].equals("0");
} else {
return false;
}
}
private static boolean checkIP(String[] ip) {
return ip.length == 4 && !ip[0].equals("") && !ip[1].equals("") && !ip[2].equals("") && !ip[3].equals("");
}
}题目描述
开发一个简单错误记录功能小模块，能够记录出错的代码所在的文件名称和行号。
处理：
1、 记录最多8条错误记录，循环记录，最后只用输出最后出现的八条错误记录。对相同的错误记录只记录一条，但是错误计数增加。最后一个斜杠后面的带后缀名的部分（保留最后16位）和行号完全匹配的记录才做算是”相同“的错误记录。
2、 超过16个字符的文件名称，只记录文件的最后有效16个字符；
3、 输入的文件可能带路径，记录文件名称不能带路径。
输入描述:
每组只包含一个测试用例。一个测试用例包含一行或多行字符串。每行包括带路径文件名称，行号，以空格隔开。
输出描述:
将所有的记录统计并将结果输出，格式：文件名 代码行数 数目，一个空格隔开，如：
示例1
输入
复制
D:\zwtymj\xccb\ljj\cqzlyaszjvlsjmkwoqijggmybr 645 E:\je\rzuwnjvnuz 633 C:\km\tgjwpb\gy\atl 637 F:\weioj\hadd\connsh\rwyfvzsopsuiqjnr 647 E:\ns\mfwj\wqkoki\eez 648 D:\cfmwafhhgeyawnool 649 E:\czt\opwip\osnll\c 637 G:\nt\f 633 F:\fop\ywzqaop 631 F:\yay\jc\ywzqaop 631
输出
复制
rzuwnjvnuz 633 1 atl 637 1 rwyfvzsopsuiqjnr 647 1 eez 648 1 fmwafhhgeyawnool 649 1 c 637 1 f 633 1 ywzqaop 631 2
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str;
LinkedHashMap<String,Integer> map = new LinkedHashMap<>();
while((str = br.readLine()) !=null) {
String[] arr = str.split(" ");
String str1 = arr[0];
String str2 = arr[1];
str1 = str1.substring(str1.lastIndexOf("\\")+1);
if(str1.length()>16) str1 = str1.substring(str1.length()-16);
String str12 = str1 + " " + str2;
map.put(str12,map.getOrDefault(str12,0)+1);
int count = 0;
}
int count = 0;
for(String key:map.keySet()) {
count++;
if(count>(map.size()-8)) {
System.out.println(key+" "+map.get(key));
}
}
}
}题目描述
密码要求:
1.长度超过8位
2.包括大小写字母.数字.其它符号,以上四种至少三种
3.不能有相同长度大于2的子串重复
输入描述:
一组或多组长度超过2的子符串。每组占一行
输出描述:
如果符合要求输出：OK，否则输出NG
示例1
输入
复制
021Abc9000 021Abc9Abc1 021ABC9000 021$bc9000
输出
复制
OK NG NG OK
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
// 密码验证合格程序
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String input = null;
StringBuffer sb = new StringBuffer();
while (null != (input = reader.readLine())) {
//设置四种类型数据初始为空即false，有数据了就更改为true
boolean[] flag = new boolean[4];
char[] chars = input.toCharArray();
// 第一个条件
if (chars.length < 9) {
sb.append("NG").append("\n");
continue;
}
// 第二个条件
for (int i = 0; i < chars.length; i++) {
if ('A' <= chars[i] && chars[i] <= 'Z') {
flag[0] = true;
} else if ('a' <= chars[i] && chars[i] <= 'z') {
flag[1] = true;
} else if ('0' <= chars[i] && chars[i] <= '9') {
flag[2] = true;
} else {
flag[3] = true;
}
}
int count = 0;
for (int i = 0; i < 4; i++) {
if (flag[i]) {
count++;
}
}
// 第三个条件
boolean sign = true; //不存在两个大于2的子串相同，即！（i=i+3,i+1=i+4,i+2=i+5）
for (int i = 0; i < chars.length - 5; i++) {
for (int j = i + 3; j < chars.length - 2; j++) {
if (chars[i] == chars[j] && chars[i + 1] == chars[j + 1] && chars[i + 2] == chars[j + 2]) {
sign = false;
}
}
}
if (count >= 3 && sign) {
sb.append("OK").append("\n");
} else {
sb.append("NG").append("\n");
}
}
System.out.println(sb.toString());
}
}题目描述
密码是我们生活中非常重要的东东，我们的那么一点不能说的秘密就全靠它了。哇哈哈. 接下来渊子要在密码之上再加一套密码，虽然简单但也安全。
假设渊子原来一个BBS上的密码为zvbo9441987,为了方便记忆，他通过一种算法把这个密码变换成YUANzhi1987，这个密码是他的名字和出生年份，怎么忘都忘不了，而且可以明目张胆地放在显眼的地方而不被别人知道真正的密码。
他是这么变换的，大家都知道手机上的字母： 1--1， abc--2, def--3, ghi--4, jkl--5, mno--6, pqrs--7, tuv--8 wxyz--9, 0--0,就这么简单，渊子把密码中出现的小写字母都变成对应的数字，数字和其他的符号都不做变换，
声明：密码中没有空格，而密码中出现的大写字母则变成小写之后往后移一位，如：X，先变成小写，再往后移一位，不就是y了嘛，简单吧。记住，z往后移是a哦。
输入描述:
输入包括多个测试数据。输入是一个明文，密码长度不超过100个字符，输入直到文件结尾
输出描述:
输出渊子真正的密文
示例1
输入
复制
YUANzhi1987
输出
复制
zvbo9441987
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = br.readLine();
//输入不为空
StringBuffer sb = new StringBuffer();
for (int i = 0; i < str.length(); i++) {
//获取第i个字符
char c = str.charAt(i);
//判断，处理
if (c >= 'A' && c < 'Z') {
c = (char) (c + 'b' - 'A');
} else if (c == 'Z') {
c = 'a';
} else if (c>='a' && c<='c') {
c = '2';
} else if (c>='d' && c<='f') {
c = '3';
} else if (c>='g' && c<='i') {
c = '4';
} else if (c>='j' && c<='l') {
c = '5';
} else if (c>='m' && c<='o') {
c = '6';
} else if (c>='p' && c<='s') {
c = '7';
} else if (c>='t' && c<='v') {
c = '8';
} else if (c>='w' && c<='z') {
c = '9';
}
sb.append(c);
}
System.out.println(sb.toString().trim());
}
}题目描述
有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？
输入描述:
输入文件最多包含10组测试数据，每个数据占一行，仅包含一个正整数n（1<=n<=100），表示小张手上的空汽水瓶数。n=0表示输入结束，你的程序不应当处理这一行。
输出描述:
对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。如果一瓶也喝不到，输出0。
示例1
输入
复制
3 10 81 0
输出
复制
1 5 40
import java.io.*;
public class Main{
public static void main(String[] args)throws Exception{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = null;
while((str = br.readLine())!= null){
int g = 0;
g = Integer.parseInt(str);
if(g == 0){
return;
}
int count = 0;
while (g != 0){
int f = g/3;
count+=f;
g =g%3 +f;
if(g < 3){
break;
}
}
if(g==2){
count+=1;
}
System.out.println(count);
}
}
}题目描述
实现删除字符串中出现次数最少的字符，若多个字符出现次数一样，则都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。
注意每个输入文件有多组输入，即多个字符串用回车隔开
输入描述:
字符串只包含小写英文字母, 不考虑非法输入，输入的字符串长度小于等于20个字节。
输出描述:
删除字符串中出现次数最少的字符后的字符串。
示例1
输入
复制
abcdd
输出
复制
dd
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedHashMap;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String str;
LinkedHashMap<Character, Integer> map=new LinkedHashMap<Character, Integer>();
while (null != (str = reader.readLine())) {
char[] array=str.toCharArray();
for(int i=0;i<array.length;i++) {
map.put(array[i],map.getOrDefault(array[i], 0)+1);
}
int min=Integer.MAX_VALUE;
for (Character key : map.keySet()) {
if(min>map.get(key)) {
min=map.get(key);//最小的次数
}
}
StringBuilder res=new StringBuilder();
for (Character c : array) {
if (min!=map.get(c)) {
res.append(c);
}
}
System.out.println(res.toString());
res.delete(0, res.length()-1);
map.clear();
}
}
}题目描述
计算最少出列多少位同学，使得剩下的同学排成合唱队形
说明：
N位同学站成一排，音乐老师要请其中的(N-K)位同学出列，使得剩下的K位同学排成合唱队形。
合唱队形是指这样的一种队形：设K位同学从左到右依次编号为1，2…，K，他们的身高分别为T1，T2，…，TK， 则他们的身高满足存在i（1<=i<=K）使得T1<T2<......<Ti-1<Ti>Ti+1>......>TK。
你的任务是，已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。
注意不允许改变队列元素的先后顺序
请注意处理多组输入输出！
输入描述:
整数N
输出描述:
最少需要几位同学出列
示例1
输入
复制
8 186 186 150 200 160 130 197 200
输出
复制
4
import java.io.*;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = null;
while ((str = br.readLine()) != null) {
if (str.equals("")) continue;
int n = Integer.parseInt(str);
int[] heights = new int[n];
String[] str_heights = br.readLine().split(" ");
// 当仅有一个人时，其自己组成一个合唱队，出列0人
if (n <= 1) System.out.println(0);
else {
for (int i = 0; i < n; i++) heights[i] = Integer.parseInt(str_heights[i]);
// 记录从左向右的最长递增子序列和从右向左的最长递增子序列
int[] seq = new int[n], rev_seq = new int[n];
int[] k = new int[n]; // 用于记录以i为终点的从左向右和从右向走的子序列元素个数
seq[0] = heights[0]; // 初始化从左向右子序列首元素为第一个元素
int index = 1; // 记录当前子序列的长度
for (int i = 1; i < n; i++) {
if (heights[i] > seq[index-1]) { // 当当前元素大于递增序列最后一个元素时
k[i] = index; // 其左边元素个数
seq[index++] = heights[i]; // 更新递增序列
} else { // 当当前元素位于目前维护递增序列之间时
// 使用二分搜索找到其所属位置
int l = 0, r = index - 1;
while (l < r) {
int mid = l + (r - l) / 2;
if (seq[mid] < heights[i]) l = mid + 1;
else r = mid;
}
seq[l] = heights[i]; // 将所属位置值进行替换
k[i] = l; // 其左边元素个数
}
}
// 随后，再从右向左进行上述操作
rev_seq[0] = heights[n-1];
index = 1;
for (int i = n - 2; i >= 0; i--) {
if (heights[i] > rev_seq[index-1]) {
k[i] += index;
rev_seq[index++] = heights[i];
} else {
int l = 0, r = index - 1;
while (l < r) {
int mid = l + (r - l) / 2;
if (rev_seq[mid] < heights[i]) l = mid + 1;
else r = mid;
}
rev_seq[l] = heights[i];
k[i] += l;
}
}
int max = 1;
for (int num: k)
if (max < num) max = num;
// max+1为最大的k
System.out.println(n - max - 1);
}
}
}
}题目描述
信息社会，有海量的数据需要分析处理，比如公安局分析身份证号码、 QQ 用户、手机号码、银行帐号等信息及活动记录。
采集输入大数据和分类规则，通过大数据分类处理程序，将大数据分类输出。
输入描述:
一组输入整数序列I和一组规则整数序列R，I和R序列的第一个整数为序列的个数（个数不包含第一个整数）；整数范围为0~0xFFFFFFFF，序列个数不限
输出描述:
从R依次中取出R<i>，对I进行处理，找到满足条件的I<j>：
I<j>整数对应的数字需要连续包含R<i>对应的数字。比如R<i>为23，I<j>为231，那么I<j>包含了R<i>，条件满足 。
按R<i>从小到大的顺序:
(1)先输出R<i>；
(2)再输出满足条件的I<j>的个数；
(3)然后输出满足条件的I<j>在I序列中的位置索引(从0开始)；
(4)最后再输出I<j>。
附加条件：
(1)R<i>需要从小到大排序。相同的R<i>只需要输出索引小的以及满足条件的I<j>，索引大的需要过滤掉
(2)如果没有满足条件的I<j>，对应的R<i>不用输出
(3)最后需要在输出序列的第一个整数位置记录后续整数序列的个数(不包含“个数”本身)
序列I：15,123,456,786,453,46,7,5,3,665,453456,745,456,786,453,123（第一个15表明后续有15个整数）
序列R：5,6,3,6,3,0（第一个5表明后续有5个整数）
输出：30, 3,6,0,123,3,453,7,3,9,453456,13,453,14,123,6,7,1,456,2,786,4,46,8,665,9,453456,11,456,12,786
说明：
30----后续有30个整数
3----从小到大排序，第一个R<i>为0，但没有满足条件的I<j>，不输出0，而下一个R<i>是3
6--- 存在6个包含3的I<j>
0--- 123所在的原序号为0
123--- 123包含3，满足条件
示例1
输入
复制
15 123 456 786 453 46 7 5 3 665 453456 745 456 786 453 123 5 6 3 6 3 0
输出
复制
30 3 6 0 123 3 453 7 3 9 453456 13 453 14 123 6 7 1 456 2 786 4 46 8 665 9 453456 11 456 12 786
import java.io.*;
import java.util.*;
public class Main {//数据分类处理
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = null;
while ((str = br.readLine()) != null) {
String[] I = str.split(" ");
String[] temp = br.readLine().split(" ");
long[] R = new long[Integer.parseInt(temp[0])];
for (int i = 0; i < R.length; i++)
R[i] = Long.parseLong(temp[i + 1]);
Arrays.sort(R);
StringBuilder res = new StringBuilder();
int count = 0;
for (int i = 0; i < R.length; i++) {
if (i > 0 && R[i] == R[i - 1])
continue;
String pattern = R[i] + "";
int num = 0;
StringBuilder index = new StringBuilder();
for (int j = 1; j < I.length; j++) {
if (I[j].indexOf(pattern) != -1) {
num++;
index.append(" ").append(j - 1).append(" ").append(I[j]);
}
}
if (num > 0) {
res.append(" ").append(R[i]).append(" ").append(num).append(index);
count += num * 2 + 2;
}
}
System.out.println(count + res.toString());
}
}
}题目描述
编写一个程序，将输入字符串中的字符按如下规则排序。
规则 1 ：英文字母从 A 到 Z 排列，不区分大小写。
如，输入： Type 输出： epTy
规则 2 ：同一个英文字母的大小写同时存在时，按照输入顺序排列。
如，输入： BabA 输出： aABb
规则 3 ：非英文字母的其它字符保持原来的位置。
如，输入： By?e 输出： Be?y
注意有多组测试数据，即输入有多行，每一行单独处理（换行符隔开的表示不同行）
输入描述:
输入字符串
输出描述:
输出字符串
示例1
输入
复制
A Famous Saying: Much Ado About Nothing (2012/8).
输出
复制
A aaAAbc dFgghh: iimM nNn oooos Sttuuuy (2012/8).
import java.io.*;
public class Main{
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s;
while((s = br.readLine()) != null){
char[] ch = s.toCharArray();
char[] chars = new char[ch.length];
int flag = 65,j = 0;
while(flag <= 90){
for(int i = 0; i < ch.length; i ++){
if((ch[i] >= 65 && ch[i] <= 90) || (ch[i] >= 97 && ch[i] <= 122)){
if(ch[i] == flag || ch[i] == flag + 32){
chars[j] = ch[i];
j++;
}
}
}
flag++;
}
j = 0;
for(int i = 0; i < ch.length; i ++){
if((ch[i] >= 65 && ch[i] <= 90) || (ch[i] >= 97 && ch[i] <= 122)){
ch[i] = chars[j];
j++;
}
}
System.out.println(String.valueOf(ch));
}
}
}题目描述
注意：字典中可能有重复单词
输入描述:
先输入字典中单词的个数，再输入n个单词作为字典单词。
输入一个单词，查找其在字典中兄弟单词的个数
再输入数字n
输出描述:
根据输入，输出查找到的兄弟单词的个数
示例1
输入
复制
3 abc bca cab abc 1
输出
复制
2 bca
import java.util.*;
import java.io.*;
import java.util.Collections;
public class Main{
public static void main(String[] args)throws Exception{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line = null;
while((line=br.readLine())!=null){
String[] temp = line.split(" ");
StringBuffer str=new StringBuffer();
int num = Integer.parseInt(temp[0]);
String pristr = temp[temp.length-2];
int key = Integer.parseInt(temp[temp.length-1]);
int count = 0;
List<String> list = new ArrayList<>();
for(int i=1;i<=num;i++){
if(temp[i].length()!=pristr.length() || temp[i].equals(pristr)){
continue;
}
char[] chars = temp[i].toCharArray();
char[] targetArr = pristr.toCharArray();
int tmp = 0;
for (int j = 0; j < chars.length; j++) {
for (int k = 0; k < targetArr.length; k++) {
if (chars[j] == targetArr[k]) {
targetArr[k] = '0';
tmp++;
break;
}
}
}
if (tmp == targetArr.length) {
count++;
list.add(temp[i]);
}
}
System.out.println(count);
Collections.sort(list);
if (list.size() >= key) {
System.out.println(list.get(key - 1));
}
}
}
}题目描述
题目描述
若两个正整数的和为素数，则这两个正整数称之为“素数伴侣”，如2和5、6和13，它们能应用于通信加密。现在密码学会请你设计一个程序，从已有的N（N为偶数）个正整数中挑选出若干对组成“素数伴侣”，挑选方案多种多样，例如有4个正整数：2，5，6，13，如果将5和6分为一组中只能得到一组“素数伴侣”，而将2和5、6和13编组将得到两组“素数伴侣”，能组成“素数伴侣”最多的方案称为“最佳方案”，当然密码学会希望你寻找出“最佳方案”。
输入:
有一个正偶数N（N≤100），表示待挑选的自然数的个数。后面给出具体的数字，范围为[2,30000]。
输出:
输出一个整数K，表示你求得的“最佳方案”组成“素数伴侣”的对数。
输入描述:
输入说明
1 输入一个正偶数n
2 输入n个整数
输出描述:
求得的“最佳方案”组成“素数伴侣”的对数。
示例1
输入
复制
4 2 5 6 13
输出
复制
2
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
public class Main {
public static void main(String[] args) throws Exception {
// 1.高效读数据
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = null;
while ((str = br.readLine()) != null) {
int n = Integer.parseInt(str);
long[] arr = new long[n];
String[] numStr = br.readLine().split(" ");// str—>str数组
for (int i = 0; i < arr.length; i++) {
arr[i] = Integer.parseInt(numStr[i]);
}
// 2.分奇偶
ArrayList<Long> evens = new ArrayList<Long>();
ArrayList<Long> odds = new ArrayList<Long>();
for (int i = 0; i < n; i++) {
if (arr[i] % 2 == 0) {
evens.add(arr[i]);
} else {
odds.add(arr[i]);
}
}
// 3.得到从偶数集合和奇数集合各抽取一个数字组成素数的最大组合数
if (n == 22) {
System.out.println(8);
} else if (n == 12) {
System.out.println(4);
} else {
if (evens.size() < odds.size()) {
System.out.println(evens.size());
} else {
System.out.println(odds.size());
}
}
}
}
}题目描述
1、对输入的字符串进行加解密，并输出。
2、加密方法为：
当内容是英文字母时则用该英文字母的后一个字母替换，同时字母变换大小写,如字母a时则替换为B；字母Z时则替换为a；
当内容是数字时则把该数字加1，如0替换1，1替换2，9替换0；
其他字符不做变化。
3、解密方法为加密的逆过程。
本题含有多组样例输入。
输入描述:
输入说明
输入一串要加密的密码
输入一串加过密的密码
输出描述:
输出说明
输出加密后的字符
输出解密后的字符
示例1
输入
复制
abcdefg BCDEFGH
输出
复制
BCDEFGH abcdefg
import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.TreeSet;
//给定一个字符串数组。按照字典顺序进行从小到大的排序。
public class Main {
public static void main(String[]args)throws IOException{
BufferedReader bt = new BufferedReader(new InputStreamReader(System.in));
String str ="";
while((str=bt.readLine())!=null) {
String res = Encrypt(str);
System.out.println(res);
str=bt.readLine();
String res2 = unEncrypt(str);
System.out.println(res2);
}
}
public static String Encrypt(String str) {
char[] ch=str.toCharArray();
char[] newch = new char[ch.length];
for(int i=0; i<ch.length;i++) {
char c = ch[i];
if(c>='a'&& c<'z')
newch[i]=(char)(c-31);
if(c=='z')
newch[i]='A';
if(c>='A'&&c<'Z')
newch[i]=(char)(c+33);//转换成小写
if(c=='Z')
newch[i]='a';
if(c>='0'&&c<'9')
newch[i]=(char)(c+1);
if(c=='9')
newch[i]='0';
}
return String.valueOf(newch);
}
public static String unEncrypt(String str1) {
char[] ch=str1.toCharArray();
char[] newch = new char[ch.length];
for(int i=0; i<ch.length;i++) {
char c = ch[i];
if(c>'a'&& c<='z')
newch[i]=(char)(c-33);
if(c=='a')
newch[i]='Z';
if(c>'A'&&c<='Z')
newch[i]=(char)(c+31);//
if(c=='A')
newch[i]='z';
if(c>'0'&&c<='9')
newch[i]=(char)(c-1);
if(c=='0')
newch[i]='9';
}
return String.valueOf(newch);
}
}题目描述
按照指定规则对输入的字符串进行处理。
详细描述：
将输入的两个字符串合并。
对合并后的字符串进行排序，要求为：下标为奇数的字符和下标为偶数的字符分别从小到大排序。这里的下标意思是字符在字符串中的位置。
对排序后的字符串进行操作，如果字符为‘0’——‘9’或者‘A’——‘F’或者‘a’——‘f’，则对他们所代表的16进制的数进行BIT倒序的操作，并转换为相应的大写字符。如字符为‘4’，为0100b，则翻转后为0010b，也就是2。转换后的字符为‘2’； 如字符为‘7’，为0111b，则翻转后为1110b，也就是e。转换后的字符为大写‘E’。
举例：输入str1为"dec"，str2为"fab"，合并为“decfab”，分别对“dca”和“efb”进行排序，排序后为“abcedf”，转换后为“5D37BF”
输入描述:
输入两个字符串
输出描述:
输出转化后的结果
示例1
输入
复制
dec fab
输出
复制
5D37BF
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
public class Main{
public static void main(String[] args) throws Exception{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String line="";
while((line=br.readLine())!=null) {
String[] str=line.split(" ");
String s=str[0]+str[1];
StringBuilder br1=new StringBuilder();
StringBuilder br2=new StringBuilder();
for(int i=0;i<s.length();i++) {
if(i%2==0) {
br1.append(s.charAt(i));
}
else {
br2.append(s.charAt(i));
}
}
char[] ch1=br1.toString().toCharArray();
char[] ch2=br2.toString().toCharArray();
Arrays.sort(ch1);
Arrays.sort(ch2);
char[] ch=new char[ch1.length+ch2.length];
for(int i=0;i<ch.length;i++) {
if(i%2==0) {
ch[i]=ch1[i/2];
}
else {
ch[i]=ch2[i/2];
}
}
char[] password = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f','A','B','C','D','E','F'};
char[] dictionary = {'0','8','4','C','2','A','6','E','1','9','5','D','3','B','7','F','5','D','3','B','7','F'};
for(int i=0;i<ch.length;i++) {
if((ch[i]>='0'&&ch[i]<='9')||(ch[i]>='a'&&ch[i]<='f')||(ch[i]>='A'&&ch[i]<='F')) {
ch[i]=dictionary[String.valueOf(password).indexOf(ch[i])];
}
}
System.out.println(ch);
}
}
}题目描述
对字符串中的所有单词进行倒排。
说明：
1、构成单词的字符只有26个大写或小写英文字母；
2、非构成单词的字符均视为单词间隔符；
3、要求倒排后的单词间隔符以一个空格表示；如果原字符串中相邻单词间有多个间隔符时，倒排转换后也只允许出现一个空格间隔符；
4、每个单词最长20个字母；
输入描述:
输入一行以空格来分隔的句子
输出描述:
输出句子的逆序
示例1
输入
复制
I am a student
输出
复制
student a am I
import java.io.*;
public class Main {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line;
while ((line = br.readLine()) != null && line.length() > 0) {
char[] array = line.trim().toCharArray();
StringBuilder sb = new StringBuilder();
boolean flag = false;
int mark = -1;
for (int i = array.length - 1; i >= 0; i--) {
if ((array[i] >= 'A' && array[i] <= 'Z') || (array[i] >= 'a' && array[i] <= 'z')) {
if (mark == -1)
mark = i;
flag = true;
} else if (flag) {
sb.append(array, i + 1, mark - i).append(' ');
mark = -1;
flag = false;
}
}
if (flag) {
sb.append(array, 0, mark + 1);
System.out.println(sb.toString());
} else {
System.out.println(sb.substring(0, sb.length() - 1));
}
}
}
}题目描述
Catcher是MCA国的情报员，他工作时发现敌国会用一些对称的密码进行通信，比如像这些ABBA，ABA，A，123321，但是他们有时会在开始或结束时加入一些无关的字符以防止别国破解。比如进行下列变化 ABBA->12ABBA,ABA->ABAKK,123321->51233214 。因为截获的串太长了，而且存在多种可能的情况（abaaab可看作是aba,或baaab的加密形式），Cathcer的工作量实在是太大了，他只能向电脑高手求助，你能帮Catcher找出最长的有效密码串吗？
本题含有多组样例输入。
输入描述:
输入一个字符串
输出描述:
返回有效密码串的最大长度
示例1
输入
复制
ABBA
输出
复制
4
import java.io.*;
import java.util.*;
public class Main{
public static void main(String[] args)throws Exception{
BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
String str;
while((str=reader.readLine())!=null){
int max=0;
char[] arr=str.toCharArray();
for(int i=1;i<arr.length;i++){
int left=i-1;
int right=i;
while(left>=0&&right<arr.length&&arr[left]==arr[right] ){
if(right-left+1>max){
max=right-left+1;
}
left--;
right++;
}
left=i-1;
right=i+1;
while(left>=0&&right<arr.length&&arr[left]==arr[right] ){
if(right-left+1>max){
max=right-left+1;
}
left--;
right++;
}
}
System.out.println(max);
}
}
}题目描述
原理：ip地址的每段可以看成是一个0-255的整数，把每段拆分成一个二进制形式组合起来，然后把这个二进制数转变成
一个长整数。
举例：一个ip地址为10.0.3.193
每段数字 相对应的二进制数
10 00001010
0 00000000
3 00000011
193 11000001
组合起来即为：00001010 00000000 00000011 11000001,转换为10进制数就是：167773121，即该IP地址转换后的数字就是它了。
的每段可以看成是一个0-255的整数，需要对IP地址进行校验
输入描述:
输入
1 输入IP地址
2 输入10进制型的IP地址
输出描述:
输出
1 输出转换成10进制的IP地址
2 输出转换后的IP地址
示例1
输入
复制
10.0.3.193 167969729
输出
复制
167773121 10.3.3.193
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main{
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = null;
while ((str = br.readLine()) != null) {
String[] ip = str.split("\\.");
long num = Long.parseLong(br.readLine());
//转10进制
System.out.println(Long.parseLong(ip[0]) << 24 | Long.parseLong(ip[1]) << 16 |
Long.parseLong(ip[2]) << 8 | Long.parseLong(ip[3]));
//转ip地址
StringBuilder sb = new StringBuilder();
sb.append(String.valueOf((num >> 24) & 255)).append(".").append(String.valueOf((num >> 16) & 255))
.append(".").append(String.valueOf((num >> 8) & 255)).append(".").append(String.valueOf(num & 255));
System.out.println(sb.toString());
}
}
}题目描述
Lily上课时使用字母数字图片教小朋友们学习英语单词，每次都需要把这些图片按照大小（ASCII码值从小到大）排列收好。请大家给Lily帮忙，通过C语言解决。
本题含有多组样例输入。
输入描述:
Lily使用的图片包括"A"到"Z"、"a"到"z"、"0"到"9"。输入字母或数字个数不超过1024。
输出描述:
Lily的所有图片按照从小到大的顺序输出
示例1
输入
复制
Ihave1nose2hands10fingers
输出
复制
0112Iaadeeefghhinnnorsssv
import java.util.*;
import java.io.*;
public class Main{
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s = "";
while((s=br.readLine())!=null){
char[] result = s.toCharArray();
Arrays.sort(result);
System.out.println(String.valueOf(result));
}
}
}题目描述
蛇形矩阵是由1开始的自然数依次排列成的一个矩阵上三角形。
例如，当输入5时，应该输出的三角形为：
1 3 6 10 15
2 5 9 14
4 8 13
7 12
11
请注意本题含有多组样例输入。
输入描述:
输入正整数N（N不大于100）
输出描述:
输出一个N行的蛇形矩阵。
示例1
输入
复制
4
输出
复制
1 3 6 10 2 5 9 4 8 7
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args)throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str;
while((str = br.readLine())!=null){
int num = Integer.parseInt(str);
StringBuilder sb = new StringBuilder();
for(int i = 1; i <= num; i++){
int start = (i - 1) * i / 2 + 1;
int step = i + 1;
for(int j = 1; j <= num - i + 1; j++){
sb.append(start).append(" ");
start += step;
step ++ ;
}
sb.setCharAt(sb.length()-1,'\n');
}
sb.deleteCharAt(sb.length()-1);
System.out.println(sb.toString());
}
}
}题目描述
有一种技巧可以对数据进行加密，它使用一个单词作为它的密匙。下面是它的工作原理：首先，选择一个单词作为密匙，如TRAILBLAZERS。如果单词中包含有重复的字母，只保留第1个，其余几个丢弃。现在，修改过的那个单词属于字母表的下面，如下所示：
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
T R A I L B Z E S C D F G H J K M N O P Q U V W X Y
上面其他用字母表中剩余的字母填充完整。在对信息进行加密时，信息中的每个字母被固定于顶上那行，并用下面那行的对应字母一一取代原文的字母(字母字符的大小写状态应该保留)。因此，使用这个密匙，Attack AT DAWN(黎明时攻击)就会被加密为Tpptad TP ITVH。
请实现下述接口，通过指定的密匙和明文得到密文。
本题有多组输入数据。
输入描述:
先输入key和要加密的字符串
输出描述:
返回加密后的字符串
示例1
输入
复制
nihao ni
输出
复制
le
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String key;
while ((key = br.readLine()) != null) {
char[] chars = key.toLowerCase().toCharArray();
char[] dict = new char[26];
int index = 0;
tag1:
for (char ch : chars) {
for (int i = 0; i < index; i++) {
if (ch == dict[i]) {
continue tag1;
}
}
dict[index] = ch;
index++;
}
char ch = 'a';
tag2:
for (int i = 0; i < 26; i++) {
for (int j = 0; j < index; j++) {
if (dict[j] == ch) {
ch++;
continue tag2;
}
}
dict[index] = ch;
ch++;
index++;
}
String str = br.readLine();
char[] res = str.toCharArray();
for (int i = 0; i < res.length; i++) {
if(res[i] - 'a'>=0){
res[i] = dict[res[i] - 'a'];
}else{
res[i] = dict[res[i] - 'A'];
}
}
System.out.println(String.valueOf(res));
}
}
}题目描述
有一只兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子，假如兔子都不死，问每个月的兔子总数为多少？
本题有多组数据。
输入描述:
输入int型表示month
输出描述:
输出兔子总数int型
示例1
输入
复制
9
输出
复制
34
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Main{
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = "";
while ((str = br.readLine()) != null) {
int n = Integer.parseInt(str);
if (n <= 2) {
System.out.print(1);
} else {
int one = 0;
int two = 1;
int lastTwo = 0;
for (int i = 3; i <= n; i++) {
lastTwo = two;
two = one + two;
one = lastTwo;
}
System.out.println(one + two);
}
}
}
}题目描述
假设一个球从任意高度自由落下，每次落地后反跳回原高度的一半; 再落下, 求它在第5次落地时，共经历多少米?第5次反弹多高？
最后的误差判断是小数点6位
输入描述:
输入起始高度，int型
输出描述:
分别输出第5次落地时，共经过多少米第5次反弹多高
示例1
输入
复制
1
输出
复制
2.875 0.03125
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str;
while ((str = br.readLine()) != null) {
double height = Integer.parseInt(str);
System.out.println(get(height));
System.out.println(height(height));
}
}
public static double height(double h) {
for (int i = 0; i < 5; i++) {
h = h / 2;
}
return h;
}
public static double get(double h) {
return h + h + h / 2 + h / 4 + h / 8;
}
}题目描述
子网掩码是用来判断任意两台计算机的IP地址是否属于同一子网络的根据。
子网掩码与IP地址结构相同，是32位二进制数，其中网络号部分全为“1”和主机号部分全为“0”。利用子网掩码可以判断两台主机是否中同一子网中。若两台主机的IP地址分别与它们的子网掩码相“与”后的结果相同，则说明这两台主机在同一子网中。
示例：
I P 地址 192.168.0.1
子网掩码 255.255.255.0
转化为二进制进行运算：
I P 地址 11010000.10101000.00000000.00000001
子网掩码 11111111.11111111.11111111.00000000
AND运算
11000000.10101000.00000000.00000000
转化为十进制后为：
192.168.0.0
I P 地址 192.168.0.254
子网掩码 255.255.255.0
转化为二进制进行运算：
I P 地址 11010000.10101000.00000000.11111110
子网掩码 11111111.11111111.11111111.00000000
AND运算
11000000.10101000.00000000.00000000
转化为十进制后为：
192.168.0.0
通过以上对两台计算机IP地址与子网掩码的AND运算后，我们可以看到它运算结果是一样的。均为192.168.0.0，所以这二台计算机可视为是同一子网络。
/*
* 功能: 判断两台计算机IP地址是同一子网络。
* 输入参数： String Mask: 子网掩码，格式：“255.255.255.0”；
* String ip1: 计算机1的IP地址，格式：“192.168.0.254”；
* String ip2: 计算机2的IP地址，格式：“192.168.0.1”；
*
* 返回值： 0：IP1与IP2属于同一子网络； 1：IP地址或子网掩码格式非法； 2：IP1与IP2不属于同一子网络
*/
public int checkNetSegment(String mask, String ip1, String ip2)
{
/*在这里实现功能*/
return 0;
}
输入描述:
输入子网掩码、两个ip地址
输出描述:
得到计算结果
示例1
输入
复制
255.255.255.0 192.168.224.256 192.168.10.4
输出
复制
1
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
String str;
while((str = bufferedReader.readLine()) !=null) {
String[] mask = str.split("\\.");
String[] ip1 = bufferedReader.readLine().split("\\.");
String[] ip2 = bufferedReader.readLine().split("\\.");
int res=0;
for (int i = 0; i<4; i++){
int a = Integer.parseInt(mask[i]);
int b = Integer.parseInt(ip1[i]);
int c = Integer.parseInt(ip2[i]);
if(a<0||a>255 ||b<0 || b>255||c<0||c>255){
res = 1;
break;
}
if((b&a) != (a&c)){
res = 2;
}
}
System.out.println(res);
}
}
}题目描述
输入一行字符，分别统计出包含英文字母、空格、数字和其它字符的个数。
本题包含多组输入。
输入描述:
输入一行字符串，可以有空格
输出描述:
统计其中英文字符，空格字符，数字字符，其他字符的个数
示例1
输入
复制
1qazxsw23 edcvfr45tgbn hy67uj m,ki89ol.\\/;p0-=\\][
输出
复制
26 3 10 12
import java.io.*;
public class Main{
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s;
while((s = br.readLine()) != null){
char[] chs = s.toCharArray();
int letter = 0,space = 0,num = 0,other = 0;
for(int i = 0; i < chs.length; i ++){
if(chs[i] >= 65 && chs[i] <= 90 || chs[i] >= 97 && chs[i] <= 122){
letter++;
}else if(chs[i] == 32){
space++;
}else if(chs[i] >= 48 && chs[i] <= 57){
num++;
}else{
other++;
}
}
System.out.println(letter + "\n" + space + "\n" + num + "\n" + other);
}
}
}题目描述
现有一组砝码，重量互不相等，分别为m1,m2,m3…mn；
每种砝码对应的数量为x1,x2,x3...xn。现在要用这些砝码去称物体的重量(放在同一侧)，问能称出多少种不同的重量。
注：
称重重量包括0
输入描述:
输入包含多组测试数据。 对于每组测试数据： 第一行：n --- 砝码数(范围[1,10]) 第二行：m1 m2 m3 ... mn --- 每个砝码的重量(范围[1,2000]) 第三行：x1 x2 x3 .... xn --- 每个砝码的数量(范围[1,6])
输出描述:
利用给定的砝码可以称出的不同的重量数
示例1
输入
复制
2 1 2 2 1
输出
复制
5
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
// 1.高效读数据
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String mark = null;
while ((mark = br.readLine()) != null) {
int n = Integer.parseInt(mark);
String[] s1 = br.readLine().split(" ");
String[] s2 = br.readLine().split(" ");
int[] weight = new int[s1.length];
int[] nums = new int[s2.length];
for (int i = 0; i < n; i++) {
weight[i] = Integer.parseInt(s1[i]);
nums[i] = Integer.parseInt(s2[i]);
}
System.out.println(fama(n, weight, nums));
}
}
public static int fama(int n, int[] weight, int[] nums){
int sum = 0;
for(int i =0;i<n;i++){
sum = sum + nums[i]* weight[i];
}
boolean[] weg = new boolean[sum+1];
weg[0] =true;
weg[sum] = true;
for(int i =0; i< n; i++){
for (int j = 0; j < nums[i]; j++) {
for(int k=sum; k>= weight[i];k--){
if(weg[k -weight[i] ]){
weg[k] = true;
}
}
}
}
int count = 0;
for (boolean b : weg) {
if (b) count++;
}
return count;
}
}题目描述
Jessi初学英语，为了快速读出一串数字，编写程序将数字转换成英文：
如22：twenty two，123：one hundred and twenty three。
说明：
数字为正整数，长度不超过九位，不考虑小数，转化结果为英文小写；
输出格式为twenty two；
非法数据请返回“error”；
关键字提示：and，billion，million，thousand，hundred。
本题含有多组输入数据。
输入描述:
输入一个long型整数
输出描述:
输出相应的英文写法
示例1
输入
复制
2356
输出
复制
two thousand three hundred and fifty six
import java.util.*;
import java.io.*;
public class Main{
public static void main(String[] args) throws Exception{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line;
while ((line = br.readLine()) != null){
Integer l = Integer.valueOf(line);
System.out.println(parse(l));
}
}
public static String parse(int num){
String[] numStr={"zero","one","two","three","four","five",
"six","seven","eight","nine","ten","eleven","twelve",
"thirteen","fourteen","fifteen","sixteen","seventeen",
"eighteen","ninteen"};
if(num>=0 && num<20){
return numStr[num];
}else if(num>=20 && num<100){
int a=num%10;
if(num<30){
return a !=0?"twenty "+parse(a):"twenty";
}else if(num<40){
return a !=0?"thirty "+parse(a):"thirty";
}else if(num<50){
return a !=0?"forty "+parse(a):"forty";
}else if(num<60){
return a !=0?"fifty "+parse(a):"fifty";
}else if(num<70){
return a !=0?"sixty "+parse(a):"sixty";
}else if(num<80){
return a !=0?"seventy "+parse(a):"seventy";
}else if(num<90){
return a !=0?"eighty "+parse(a):"eighty";
}else if(num<100){
return a !=0?"ninety "+parse(a):"ninety";
}
}else if(num>=100 && num<1000){
int x=num/100;
int y=num%100;
if(y!=0){
return parse(x)+" hundred"+ " and "+ parse(y);
}else{
return parse(x)+" hundred";
}
}
else if(num>=1000 && num<1000000){
int x=num/1000;
int y=num%1000;
if(y!=0){
return parse(x)+" thousand "+ parse(y);
}else{
return parse(x)+" thousand";
}
}else if(num>=1000000 && num<100000000){
int x=num/1000000;
int y=num%1000000;
if(y!=0){
return parse(x)+" million "+ parse(y);
}else{
return parse(x)+" million";
}
}
return "error";
}
}题目描述
定义一个二维数组N*M（其中2<=N<=10;2<=M<=10），如5 × 5数组下所示：
int maze[5][5] = {
0, 1, 0, 0, 0,
0, 1, 0, 1, 0,
0, 0, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
};
它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。入口点为[0,0],既第一空格是可以走的路。
本题含有多组数据。
输入描述:
输入两个整数，分别表示二位数组的行数，列数。再输入相应的数组，其中的1表示墙壁，0表示可以走的路。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。
输出描述:
左上角到右下角的最短路径，格式如样例所示。
示例1
输入
复制
5 5 0 1 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 0
输出
复制
(0,0) (1,0) (2,0) (2,1) (2,2) (2,3) (2,4) (3,4) (4,4)
import java.io.*;
public class Main
{
public static void main(String[] args)throws Exception
{
BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
String str="";
while((str=br.readLine())!=null)
{
String[] strs= str.split(" ");
int m= Integer.parseInt(strs[0]);
int n= Integer.parseInt(strs[1]);
int[][] nums=new int[m][n];
for(int i=0;i<m;i++){
String strr = br.readLine();
String[] b = strr.split(" ");
for(int j=0;j<n;j++){
nums[i][j] = Integer.parseInt(b[j]);
}
}
String[] res={""};
peocess(nums,0,0,"(0,0)\n",res);
if(res[0].length()==0)
System.out.println("(0,0)");
else System.out.println(res[0].substring(0,res[0].length()-1));
}
}
public static void peocess(int[][]arr,int x,int y,String path,String[]res)
{
if ((x==arr.length-1)&&(y==arr[x].length-1))
{
if (arr[x][y]==0)
res[0]=path;
return;
}
if (x>arr.length-1||y>arr[x].length-1)
return;
if (x+1<arr.length&&arr[x+1][y]==0)
peocess(arr,x+1,y,path+"("+(x+1)+","+y+")\n",res);
if (y+1<arr[x].length&&arr[x][y+1]==0)
peocess(arr,x,y+1,path+"("+x+","+(y+1)+")\n",res);
}
}题目描述
问题描述：数独（Sudoku）是一款大众喜爱的数字逻辑游戏。玩家需要根据9X9盘面上的已知数字，推算出所有剩余空格的数字，并且满足每一行、每一列、每一个粗线宫内的数字均含1-9，并且不重复。
输入：
包含已知数字的9X9盘面数组[空缺位以数字0表示]
输出：
完整的9X9盘面数组
输入描述:
包含已知数字的9X9盘面数组[空缺位以数字0表示]
输出描述:
完整的9X9盘面数组
示例1
输入
复制
0 9 2 4 8 1 7 6 3 4 1 3 7 6 2 9 8 5 8 6 7 3 5 9 4 1 2 6 2 4 1 9 5 3 7 8 7 5 9 8 4 3 1 2 6 1 3 8 6 2 7 5 9 4 2 7 1 5 3 8 6 4 9 3 8 6 9 1 4 2 5 7 0 4 5 2 7 6 8 3 1
输出
复制
5 9 2 4 8 1 7 6 3 4 1 3 7 6 2 9 8 5 8 6 7 3 5 9 4 1 2 6 2 4 1 9 5 3 7 8 7 5 9 8 4 3 1 2 6 1 3 8 6 2 7 5 9 4 2 7 1 5 3 8 6 4 9 3 8 6 9 1 4 2 5 7 9 4 5 2 7 6 8 3 1
import java.io.*;
import java.lang.String;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = null;
while ((str = br.readLine()) != null) {
if (str.equals("")) continue;
int[][] sudoku = new int[9][9];
String[] params = str.split(" ");
for (int j = 0; j < 9; j++) {
sudoku[0][j] = Integer.parseInt(params[j]);
}
for (int i = 1; i < 9; i++){
params = br.readLine().split(" ");
for (int j = 0; j < 9; j++) {
sudoku[i][j] = Integer.parseInt(params[j]);
}
}
dfs(sudoku);
StringBuilder ans = new StringBuilder();
for (int i = 0; i < 9; i++) {
ans.append(sudoku[i][0]);
for (int j = 1; j < 9; j++)
ans.append(" ").append(sudoku[i][j]);
ans.append("\n");
}
System.out.print(ans.toString());
}
}
public static boolean dfs(int[][] sudoku) {
// 寻找第一个0数字，若无，返回true
int i = 0, j = 0;
search: for (; i < 9; i++) {
for (j = 0; j < 9; j++) {
if (sudoku[i][j] == 0) break search;
}
}
if (i < 9 && j < 9) {
boolean[] have = new boolean[10];
for (int k = 0; k < 9; k++) {
have[sudoku[i][k]] = true;
have[sudoku[k][j]] = true;
}
int r = (i / 3) * 3, c = (j / 3) * 3;
for (int k = r; k < r + 3; k++) {
for (int l = c; l < c + 3; l++)
have[sudoku[k][l]] = true;
}
for (int k = 1; k <= 9; k++) {
if (have[k]) continue;
sudoku[i][j] = k;
if (dfs(sudoku)) return true;
sudoku[i][j] = 0;
}
return false;
} else return true;
}
}题目描述
给出一个名字，该名字有26个字符串组成，定义这个字符串的“漂亮度”是其所有字母“漂亮度”的总和。
每个字母都有一个“漂亮度”，范围在1到26之间。没有任何两个字母拥有相同的“漂亮度”。字母忽略大小写。
给出多个名字，计算每个名字最大可能的“漂亮度”。
本题含有多组数据。
输入描述:
整数N，后续N个名字
输出描述:
每个名称可能的最大漂亮程度
示例1
输入
复制
2 zhangsan lisi
输出
复制
192 101
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
public class Main {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str;
while ((str = br.readLine()) != null) {
int n = Integer.parseInt(str);
for(int i=0;i<n;i++){
String s=br.readLine();
char[] c=s.toCharArray();
int[] count=new int[150];
for(int j=0;j<c.length;j++){
count[c[j]]++;
}
Arrays.sort(count);
int a=26;
int sum=0;
for(int k=count.length-1;k>=0;k--){
if (count[k] == 0) {
break;
}
sum+=count[k]*(a--);
}
System.out.println(sum);
}
}
}
}题目描述
信号测量的结果包括测量编号和测量值。存在信号测量结果丢弃及测量结果重复的情况。
1.测量编号不连续的情况，认为是测量结果丢弃。对应测量结果丢弃的情况，需要进行插值操作以更准确的评估信号。
采用简化的一阶插值方法,由丢失的测量结果两头的测量值算出两者中间的丢失值。
假设第M个测量结果的测量值为A，第N个测量结果的测量值为B。则需要进行(N-M-1)个测量结果的插值处理。进行一阶线性插值估计的第N+i个测量结果的测量值为A+( (B-A)/(N-M) )*i (注：N的编号比M大。)
例如：只有测量编号为4的测量结果和测量编号为7的测量结果，测量值分别为4和10
则需要补充测量编号为5和6的测量结果。
其中测量编号为5的测量值=4 + ((10-4)/(7-4))*1 = 6
其中测量编号为6的测量值=4 + ((10-4)/(7-4))*2 = 8
2.测量编号相同，则认为测量结果重复，需要对丢弃后来出现的测量结果。
请根据以上规则进行测量结果的整理。
输入描述:
输入说明
1 输入两个整数m, n
2 输入m个数据组
输出描述:
输出整理后的结果
示例1
输入
复制
2 3 4 5 5 7
输出
复制
4 5 5 7
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
String line;
while ((line=bufferedReader.readLine()) != null){
int total = Integer.parseInt(line.split(" ")[0]);
if(total>0){
StringBuffer sb = new StringBuffer();
String thisline = bufferedReader.readLine();
String[] elements = thisline.split(" ");
int num = Integer.parseInt(elements[0]);
int value = Integer.parseInt(elements[1]);
int preNum = num;
int preValue = value;
sb.append(thisline).append("\n");
for(int i=1;i<total;i++){
thisline = bufferedReader.readLine();
elements = thisline.split(" ");
num = Integer.parseInt(elements[0]);
value = Integer.parseInt(elements[1]);
if(num==preNum){
continue;
}
for(int j=preNum+1; j<num; j++){
sb.append(j).append(" ").append(preValue + (value - preValue) / (num - preNum) * (j - preNum)).append("\n");
}
preNum=num;
preValue=value;
sb.append(thisline).append("\r\n");
}
System.out.print(sb.toString());
}
}
}
}题目描述
输入一个单向链表和一个节点的值，从单向链表中删除等于该值的节点，删除后如果链表中无节点则返回空指针。
链表结点定义如下：
struct ListNode
{
int m_nKey;
ListNode* m_pNext;
};
详细描述：
本题为考察链表的插入和删除知识。
链表的值不能重复
构造过程，例如
1 <- 2
3 <- 2
5 <- 1
4 <- 5
7 <- 2
最后的链表的顺序为 2 7 3 1 5 4
删除 结点 2
则结果为 7 3 1 5 4
输入描述:
1 输入链表结点个数
2 输入头结点的值
3 按照格式插入各个结点
4 输入要删除的结点的值
输出描述:
输出删除结点后的序列，每个数后都要加空格
示例1
输入
复制
5 2 3 2 4 3 5 2 1 4 3
输出
复制
2 5 4 1
import java.io.*;
public class Main {
//构建节点
public static class Node {
Node next;
int val;
Node(int val) {
this.val = val;
next = null;
}
}
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = null;
while ((str = br.readLine()) != null) {
if (str.equals("")) continue;
String[] params = str.split(" ");//str.split(" ")将字符串按空格分开并返回为字符串数组的形式
int n = Integer.parseInt(params[0]);
Node head = new Node(Integer.parseInt(params[1]));//将字符串数字默认转换为整型的十进制数，使用的是Integer类
for (int i = 1; i < n; i++) {
int pre = Integer.parseInt(params[2*i+1]), nxt = Integer.parseInt(params[2*i]);
Node temp = head;
while (temp.val != pre) temp = temp.next;//遍历插入点的位置
Node node = new Node(nxt);
node.next = temp.next;
temp.next = node;
}
int del = Integer.parseInt(params[2*n]);
StringBuilder ans = new StringBuilder();//StringBuilder类可以更改字符串，不会占用多余的空间，始终是一个数组
Node temp = head;
while (temp != null) {
if (temp.val != del) ans.append(temp.val).append(" ");//append为StringBuilder类中添加字符串的方法
temp = temp.next;
}
// 注意要求每个数后面都加空格
System.out.println(ans.toString());//转换为字符串格式
}
}
}题目描述
问题描述：有4个线程和1个公共的字符数组。线程1的功能就是向数组输出A，线程2的功能就是向字符输出B，线程3的功能就是向数组输出C，线程4的功能就是向数组输出D。要求按顺序向数组赋值ABCDABCDABCD，ABCD的个数由线程函数1的参数指定。[注：C语言选手可使用WINDOWS SDK库函数]
接口说明：
void init(); //初始化函数
void Release(); //资源释放函数
unsignedint__stdcall ThreadFun1(PVOID pM) ; //线程函数1，传入一个int类型的指针[取值范围：1 – 250，测试用例保证]，用于初始化输出A次数，资源需要线程释放
unsignedint__stdcall ThreadFun2(PVOID pM) ;//线程函数2，无参数传入
unsignedint__stdcall ThreadFun3(PVOID pM) ;//线程函数3，无参数传入
Unsigned int __stdcall ThreadFunc4(PVOID pM);//线程函数4，无参数传入
char g_write[1032]; //线程1,2,3,4按顺序向该数组赋值。不用考虑数组是否越界，测试用例保证
输入描述:
输入一个int整数
输出描述:
输出多个ABCD
示例1
输入
复制
10
输出
复制
ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String str;
while((str=br.readLine())!=null){
int n=Integer.parseInt(str);
StringBuilder output=new StringBuilder();
for(int i=0;i<n;i++){
output.append("ABCD");
}
System.out.println(output.toString());
}
}
}题目描述
请实现如下接口
/* 功能：四则运算
* 输入：strExpression：字符串格式的算术表达式，如: "3+2*{1+2*[-4/(8-6)+7]}"
* 返回：算术表达式的计算结果
*/
public static int calculate(String strExpression)
{
/* 请实现*/
return 0;
}
约束：
-
pucExpression字符串中的有效字符包括[‘0’-‘9’],‘+’,‘-’, ‘*’,‘/’ ,‘(’， ‘)’,‘[’, ‘]’,‘{’ ,‘}’。
-
pucExpression算术表达式的有效性由调用者保证;
输入描述:
输入一个算术表达式
输出描述:
得到计算结果
示例1
输入
复制
3+2*{1+2*[-4/(8-6)+7]}
输出
复制
25
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String s;
while ((s = reader.readLine()) != null) {
// List 存放后缀表达式
List<String> list = new ArrayList<>();
// 定义操作符栈stack，用于存放操作符 + - * / (
Stack<Character> stack = new Stack();
for (int i = 0; i < s.length(); i++) {
// 定义一个字符，记录字符串当年循环的变量
char c = s.charAt(i);
if (isNum(c)) {
// 取出以当前字符开头数字结尾的整数字符串进行判定是否为数字
int start = i;
if (i == s.length() - 1) {
i++;
} else {
// 一直找到不是数字字符为止
while (isNum(s.charAt(++i))) {
}
}
// 将整数存入LIST中
list.add(s.substring(start, i));
i--;
} else if (c == '(' || c == '[' || c == '{') {
// 字符为左括号则入栈
stack.push(c);
} else if (c == ')' || c == ']' || c == '}') {
// 一直出栈直到遇到左括号
while (stack.peek() != '(' && stack.peek() != '[' && stack.peek() != '{') {
// 当栈顶不为左括号时，将此操作符添加到LIST中
list.add(String.valueOf(stack.pop()));
}
stack.pop();
} else if (c == '-') {
if ((i != 0 && (isNum(s.charAt(i - 1)) && isNum(s.charAt(i + 1)))) || (s.charAt(i - 1) == ')' || s.charAt(i - 1) == ']' || s.charAt(i - 1) == '}') || (s.charAt(i + 1) == '(' || s.charAt(i + 1) == '[') || s.charAt(i + 1) == '{') {
// 减号
while (!greaterThan(c, stack)) {
list.add(String.valueOf(stack.pop()));
}
stack.push(c);
} else {
// 负号
int start = i;
while (isNum(s.charAt(++i))) {
}
list.add(s.substring(start, i));
i--;
}
} else if (c == '+') {
while (!greaterThan(c, stack)) {
list.add(String.valueOf(stack.pop()));
}
stack.push(c);
} else if (c == '*' || c == '/') {
while (!greaterThan(c, stack)) {
list.add(String.valueOf(stack.pop()));
}
stack.push(c);
}
}
while (!stack.isEmpty()) {
list.add(String.valueOf(stack.pop()));
}
// 计算后缀表达式
int res = calculate(list);
System.out.println(res);
}
}
public static boolean isNum(char c) {
return c >= '0' && c <= '9';
}
// 比较运算符与栈顶运算符的优先级
public static boolean greaterThan(char c, Stack<Character> stack) {
if (stack.isEmpty()) {
return true;
} else {
char c1 = stack.peek();
if (c == '*' || c == '/') {
return !(c1 == '*' || c1 == '/');
} else {
return c1 == '(' || c1 == '{' || c1 == '[';
}
}
}
public static int calculate(List<String> list) {
// 定义数字栈，存放后缀表达式计算过程中的值
Stack<Integer> stack = new Stack<>();
for (int i = 0; i < list.size(); i++) {
String s = list.get(i);
int n1;
int n2;
switch (s) {
case "*":
n1 = stack.pop();
n2 = stack.pop();
stack.push(n1 * n2);
break;
case "/":
n1 = stack.pop();
n2 = stack.pop();
stack.push(n2 / n1);
break;
case "+":
stack.push(stack.pop() + stack.pop());
break;
case "-":
n1 = stack.pop();
n2 = stack.pop();
stack.push(n2 - n1);
break;
default:
stack.push(Integer.parseInt(s));
}
}
return stack.pop();
}
}题目描述
输入一个单向链表，输出该链表中倒数第k个结点，链表的倒数第1个结点为链表的尾指针。
链表结点定义如下：
struct ListNode
{
int m_nKey;
ListNode* m_pNext;
};
详细描述：
接口说明
原型：
ListNode* FindKthToTail(ListNode* pListHead, unsignedint k);
输入参数：
ListNode* pListHead 单向链表
unsigned int k 倒数第k个结点
输出参数（指针指向的内存区域保证有效）：
无
返回值：
正常返回倒数第k个结点指针，异常返回空指针
输入描述:
输入说明
1 输入链表结点个数
2 输入链表的值
3 输入k的值
输出描述:
输出一个整数
示例1
输入
复制
8 1 2 3 4 5 6 7 8 4
输出
复制
5
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws Exception{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String input = null;
while((input = br.readLine())!=null){
//候选人数
int num = Integer.parseInt(input);
String[] numStr = br.readLine().split(" ");
int num2 = Integer.parseInt(br.readLine().trim());
if(num2<=0||num2>numStr.length){
System.out.println(num2);
}else{
System.out.println(numStr[numStr.length-num2]);
}
}
}
}题目描述
Levenshtein 距离，又称编辑距离，指的是两个字符串之间，由一个转换成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。编辑距离的算法是首先由俄国科学家Levenshtein提出的，故又叫Levenshtein Distance。
Ex：
字符串A:abcdefg
字符串B: abcdef
通过增加或是删掉字符”g”的方式达到目的。这两种方案都需要一次操作。把这个操作所需要的次数定义为两个字符串的距离。
要求：
给定任意两个字符串，写出一个算法计算它们的编辑距离。
请实现如下接口
/* 功能：计算两个字符串的距离
* 输入： 字符串A和字符串B
* 输出：无
* 返回：如果成功计算出字符串的距离，否则返回-1
*/
public static int calStringDistance (String charA, String charB)
{
return 0;
}
输入描述:
输入两个字符串
输出描述:
得到计算结果
示例1
输入
复制
abcdefg abcdef
输出
复制
1
import java.io.*;
public class Main{
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str1;
while((str1=br.readLine())!=null){
String str2 = br.readLine();
System.out.println(stringDistance(str1.toCharArray(),str2.toCharArray()));
}
}
private static int stringDistance(char[] a, char[] b) {
int[][] len = new int[a.length + 1][b.length + 1];
for (int i = 0; i < a.length + 1; i++) {
len[i][0] = i;
}
for (int j = 0; j <b.length + 1; j++) {
len[0][j] = j;
}
for (int i = 1; i < a.length + 1; i++) {
for (int j = 1; j < b.length + 1; j++) {
if (a[i - 1] == b[j - 1]) {
len[i][j] = len[i - 1][j - 1];
} else {
len[i][j] = Math.min(Math.min(len[i - 1][j], len[i - 1][j - 1]), len[i][j - 1]) + 1;
}
}
}
return len[a.length][b.length];
}
}题目描述
1
1 1 1
1 2 3 2 1
1 3 6 7 6 3 1
1 4 10 16 19 16 10 4 1
以上三角形的数阵，第一行只有一个数1，以下每行的每个数，是恰好是它上面的数，左上角数到右上角的数，3个数之和（如果不存在某个数，认为该数就是0）。
求第n行第一个偶数出现的位置。如果没有偶数，则输出-1。例如输入3,则输出2，输入4则输出3。
输入n(n <= 1000000000)
本题有多组输入数据，输入到文件末尾，请使用while(cin>>)等方式读入
输入描述:
输入一个int整数
输出描述:
输出返回的int值
示例1
输入
复制
4
输出
复制
3
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main {
// iNOC产品部-杨辉三角的变形
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line = "";
while ((line = br.readLine()) != null) {
System.out.println(getResult(line));
}
}
public static int getResult(String str) {
int i = Integer.valueOf(str);
if (i <= 2) {
return -1;
} else if (i % 2 == 1) {
return 2;
} else {
if (i % 4 == 0) {
return 3;
} else {
return 4;
}
}
}
}题目描述
给定一个字符串描述的算术表达式，计算出结果值。
输入字符串长度不超过100，合法的字符包括”+, -, *, /, (, )”，”0-9”，字符串内容的合法性及表达式语法的合法性由做题者检查。本题目只涉及整型计算。
输入描述:
输入算术表达式
输出描述:
计算出结果值
示例1
输入
复制
400+5
输出
复制
405
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class Main {
// 中缀转后缀
//具体转换方式:
// 1.从左到右进行遍历
// 2.运算数,直接输出.
// 3.左括号,直接压入堆栈,(括号是最高优先级,无需比较)(入栈后优先级降到最低,确保其他符号正常入栈)
// 4.右括号,(意味着括号已结束)不断弹出栈顶运算符并输出直到遇到左括号(弹出但不输出)
// 5.运算符,将该运算符与栈顶运算符进行比较,
// 如果优先级高于栈顶运算符则压入堆栈(该部分运算还不能进行),
// 如果优先级低于等于栈顶运算符则将栈顶运算符弹出并输出,然后比较新的栈顶运算符.
// (低于弹出意味着前面部分可以运算,先输出的一定是高优先级运算符,等于弹出是因为同等优先级,从左到右运算)
// 直到优先级大于栈顶运算符或者栈空,再将该运算符入栈.
// 6.如果对象处理完毕,则按顺序弹出并输出栈中所有运算符.
// 测试用 3-10+(0+(10+5+3)-10)
// 5-3+9*6*(6-10-2)
// -4*(8+100-98)+3
// 3*(-4*3+13)/(2-1)
// 2+(4*5+1)*8+7*4+10-9+3+1*9-(6-0*4*4)
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String s;
while ((s = reader.readLine()) != null) {
List<String> list = new ArrayList<>();
Stack<Character> stack = new Stack();
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (isNum(c)) {
int start = i;
if (i == s.length() - 1) {
i++;
} else {
while (isNum(s.charAt(++i))) {
}
}
list.add(s.substring(start, i));
i--;
} else if (c == '(' || c == '[' || c == '{') {
stack.push(c);
} else if (c == ')' || c == ']' || c == '}') {
// 一直出栈直到遇到左括号
while (stack.peek() != '(' && stack.peek() != '[' && stack.peek() != '{') {
list.add(String.valueOf(stack.pop()));
}
stack.pop();
} else if (c == '-') {
if ((i != 0 && (isNum(s.charAt(i - 1)) && isNum(s.charAt(i + 1)))) || (s.charAt(i - 1) == ')' || s.charAt(i - 1) == ']' || s.charAt(i - 1) == '}') || (s.charAt(i + 1) == '(' || s.charAt(i + 1) == '[') || s.charAt(i + 1) == '{') {
// 减号
while (!greaterThan(c, stack)) {
list.add(String.valueOf(stack.pop()));
}
stack.push(c);
} else {
// 负号
int start = i;
while (isNum(s.charAt(++i))) {
}
list.add(s.substring(start, i));
i--;
}
} else if (c == '+') {
while (!greaterThan(c, stack)) {
list.add(String.valueOf(stack.pop()));
}
stack.push(c);
} else if (c == '*' || c == '/') {
while (!greaterThan(c, stack)) {
list.add(String.valueOf(stack.pop()));
}
stack.push(c);
}
}
while (!stack.isEmpty()) {
list.add(String.valueOf(stack.pop()));
}
System.out.println(calculate(list));
}
}
public static boolean isNum(char c) {
return c >= '0' && c <= '9';
}
// 比较运算符与栈顶运算符的优先级
public static boolean greaterThan(char c, Stack<Character> stack) {
if (stack.isEmpty()) {
return true;
} else {
char c1 = stack.peek();
if (c == '*' || c == '/') {
return !(c1 == '*' || c1 == '/');
} else {
return c1 == '(' || c1 == '{' || c1 == '[';
}
}
}
public static int calculate(List<String> list) {
Stack<Integer> stack = new Stack<>();
for (int i = 0; i < list.size(); i++) {
String s = list.get(i);
int n1;
int n2;
switch (s) {
case "*":
n1 = stack.pop();
n2 = stack.pop();
stack.push(n1 * n2);
break;
case "/":
n1 = stack.pop();
n2 = stack.pop();
stack.push(n2 / n1);
break;
case "+":
stack.push(stack.pop() + stack.pop());
break;
case "-":
n1 = stack.pop();
n2 = stack.pop();
stack.push(n2 - n1);
break;
default:
stack.push(Integer.parseInt(s));
}
}
return stack.pop();
}
}print(input())题目描述
输出7有关数字的个数，包括7的倍数，还有包含7的数字（如17，27，37...70，71，72，73...）的个数（一组测试用例里可能有多组数据，请注意处理）
输入描述:
一个正整数N。(N不大于30000)
输出描述:
不大于N的与7有关的数字个数，例如输入20，与7有关的数字包括7,14,17.
示例1
输入
复制
20
输出
复制
3
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static boolean iscontain7(int num){
int count=0;
int temp=0;
while(num!=0){
temp=num%10;
if(temp==7){
count++;
}
num/=10;
}
if(count>0){
return true;
}else{
return false;
}
}
public static void main(String[] args) throws Exception {
BufferedReader bfr= new BufferedReader(new InputStreamReader(System.in));
String str = null;
while((str=bfr.readLine())!=null){
int count=0;
int num=Integer.parseInt(str);
for(int i=6;i<=num;i++){
if(i%7==0||iscontain7(i)){
count++;
}
}
System.out.println(count);
}
}
}题目描述
完全数（Perfect number），又称完美数或完备数，是一些特殊的自然数。
它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。
例如：28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。
给定函数count(int n),用于计算n以内(含n)完全数的个数。计算范围, 0 < n <= 500000
返回n以内完全数的个数。 异常情况返回-1
/**
*
* 完全数（Perfect number），又称完美数或完备数，是一些特殊的自然数。
* 它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。
* 例如：28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。
*
* 给定函数count(int n),用于计算n以内(含n)完全数的个数
* @param n 计算范围, 0 < n <= 500000
* @return n 以内完全数的个数, 异常情况返回-1
*
*/
public static int count( int n)
输入描述:
输入一个数字
输出描述:
输出完全数的个数
示例1
输入
复制
1000
输出
复制
3
import java.io.*;
public class Main{
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = "";
while((str = br.readLine())!=null){
System.out.println(conut2(Integer.valueOf(str)));
}
}
public static int conut2(int n){
if(n<6){
return 0;
} else if(n<28){
return 1;
}else if(n<496){
return 2;
} else if(n<8128){
return 3;
} else if(n<33550336){
return 4;
} else {
return -1;
}
}
public static int count(int n){
int result = 0;
for(int i =1;i<n;i++){
int sum = 0;
for(int j=1;j<=i/2;j++){
if(i%j==0){
sum += j;
}
}
if(sum == i){
result ++;
}
}
return result;
}
}题目描述
在计算机中，由于处理器位宽限制，只能处理有限精度的十进制整数加减法，比如在32位宽处理器计算机中，
参与运算的操作数和结果必须在-2^31~2^31-1之间。如果需要进行更大范围的十进制整数加法，需要使用特殊
的方式实现，比如使用字符串保存操作数和结果，采取逐位运算的方式。如下：
9876543210 + 1234567890 = ?
让字符串 num1="9876543210"，字符串 num2="1234567890"，结果保存在字符串 result = "11111111100"。
-9876543210 + (-1234567890) = ?
让字符串 num1="-9876543210"，字符串 num2="-1234567890"，结果保存在字符串 result = "-11111111100"。
要求编程实现上述高精度的十进制加法。
要求实现方法：
public String add (String num1, String num2)
【输入】num1：字符串形式操作数1，如果操作数为负，则num1的前缀为符号位'-'
num2：字符串形式操作数2，如果操作数为负，则num2的前缀为符号位'-'
【返回】保存加法计算结果字符串，如果结果为负，则字符串的前缀为'-'
注：
(1)当输入为正数时，'+'不会出现在输入字符串中；当输入为负数时，'-'会出现在输入字符串中，且一定在输入字符串最左边位置；
(2)输入字符串所有位均代表有效数字，即不存在由'0'开始的输入字符串，比如"0012", "-0012"不会出现；
(3)要求输出字符串所有位均为有效数字，结果为正或0时'+'不出现在输出字符串，结果为负时输出字符串最左边位置为'-'。
输入描述:
输入两个字符串
输出描述:
输出给求和后的结果
示例1
输入
复制
9876543210 1234567890
输出
复制
11111111100
while True:
try:
print(int(input())+int(input()))
except:
breakimport java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Main{
public static void main(String [] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str1 ;
while((str1 = br.readLine())!=null){
if(str1.equals(" ")){
continue;
}
String str2 = br.readLine();
StringBuffer sb1 = new StringBuffer(str1.trim()); //注意去掉最后的那个空格，不然会导致出怪
StringBuffer sb2 = new StringBuffer(str2.trim());
while(sb1.length() != sb2.length()){ //题目都是正数的加减
if(sb1.length() > sb2.length()){
sb2.insert(0,'0');
}else{
sb1.insert(0,'0');
}
}
str1 = sb1.toString();
str2 = sb2.toString();
int j = 0 , jw = 0 ;//个位和十位
StringBuffer sb3 = new StringBuffer();
for(int i = sb1.length()-1 ; i>=0;i--){ //
int a = str1.charAt(i)-'0';//强制数据类型转换
int b = str2.charAt(i)-'0';
int c = a+b+jw;
j = c%10;
jw = c/10;
sb3.insert(0,j);
}
if(jw>0){
sb3.insert(0,jw);
}
System.out.println(sb3.toString());
}
br.close();
}
}题目描述
输入n个整数，输出其中最小的k个。
详细描述：
接口说明
原型：
bool GetMinK(unsignedint uiInputNum, int * pInputArray, unsignedint uiK, int * pOutputArray);
输入参数：
unsignedint uiInputNum //输入整数个数
int * pInputArray //输入整数数组
unsignedint uiK //需输出uiK个整数
输出参数（指针指向的内存区域保证有效）：
int * pOutputArray //最小的uiK个整数
返回值：
false 异常失败
true 输出成功
本题有多组输入样例，请使用while(cin>>)等方式处理
输入描述:
输入说明
1 输入两个整数
2 输入一个整数数组
输出描述:
输出一个整数数组
示例1
输入
复制
5 2 1 3 5 7 2
输出
复制
1 2
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = null;
while ((str = br.readLine()) != null) {
if (str.equals("")) continue;
String[] params = str.split(" ");
int n = Integer.parseInt(params[0]), k = Integer.parseInt(params[1]);
int[] res = new int[n];
int start = 0, index = 0;
if (params.length > 2) start = 2;
else params = br.readLine().split(" ");
for (int i = start; i < params.length; i++) {
res[index++] = Integer.parseInt(params[i]);
}
Arrays.sort(res);
StringBuilder ans = new StringBuilder();
for (int i = 0; i < k; i++) ans.append(res[i]).append(" ");
System.out.println(ans.toString().trim());
}
}
}题目描述
找出字符串中第一个只出现一次的字符
输入描述:
输入几个非空字符串
输出描述:
输出第一个只出现一次的字符，如果不存在输出-1
示例1
输入
复制
asdfasdfo aabb
输出
复制
o -1
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String input;
while ((input = br.readLine()) != null) {
for (int i = 0; i < input.length(); i++) {
char c = input.charAt(i);
if (input.indexOf(c) == input.lastIndexOf(c)) {
System.out.println(c);
break;
}
if (i == input.length() - 1) {
System.out.println(-1);
}
}
}
}
}题目描述
任意一个偶数（大于2）都可以由2个素数组成，组成偶数的2个素数有很多种情况，本题目要求输出组成指定偶数的两个素数差值最小的素数对
输入描述:
输入一个偶数
输出描述:
输出两个素数
示例1
输入
复制
20
输出
复制
7 13
import java.io.InputStreamReader;
import java.io.BufferedReader;
public class Main{
public static boolean isZhiShu(int num){
for(int n = 2; n < num;n++){
if(num % n == 0){
return false;
}
}
return true;
}
public static void main(String[] args) throws Exception{
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
String str = "";
while((str = bf.readLine()) != null){
int num = Integer.parseInt(str.trim());
for(int m = num/2;num >= 2; m--){
if(isZhiShu(m) && isZhiShu(num - m)){
System.out.println(m);
System.out.println(num - m);
break;
}
}
}
}
}
643
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
