挑7
题目描述
输出7有关数字的个数，包括7的倍数，还有包含7的数字（如17，27，37...70，71，72，73...）的个数（一组测试用例里可能有多组数据，请注意处理）
输入描述:
一个正整数N。(N不大于30000)
输出描述:
不大于N的与7有关的数字个数，例如输入20，与7有关的数字包括7,14,17.
示例1
输入
20
10
输出
3
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 input = "";
while ((input = bufferedReader.readLine()) != null) {
int count=0;
int num=Integer.parseInt(input);
for(int i=7;i<=num;i++){
if(i%7==0||contain7(i)){
count++;
}
}
System.out.println(count);
}
}
public static boolean contain7(int n) {
while (n > 0) {
if (n % 10 == 7) {
return true;
} else {
n /= 10;
}
}
return false;
}
}
完全数计算
题目描述
完全数（Perfect number），又称完美数或完备数，是一些特殊的自然数。
它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。
例如：28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。s
输入n，请输出n以内(含n)完全数的个数。计算范围, 0 < n <= 500000
本题输入含有多组样例。
输入描述:
输入一个数字n
输出描述:
输出不超过n的完全数的个数
示例1
输入
1000
7
100
输出
3
1
2
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;
}
}
高精度整数加法
题目描述
输入两个用字符串表示的整数，求它们所表示的数之和。
字符串的长度不超过10000。
本题含有多组样例输入。
输入描述:
输入两个字符串。保证字符串只含有'0'~'9'字符
输出描述:
输出求和后的结果
示例1
输入
9876543210
1234567890
输出
11111111100
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 line;
while ((line = br.readLine()) != null && line.length() > 0) {
System.out.println(add(line.trim(), br.readLine().trim()));
}
}
static String add(String s1, String s2) {
if (s1.length() == 0 || s2.length() == 0)
return "";
boolean neg1 = s1.charAt(0) == '-';
boolean neg2 = s2.charAt(0) == '-';
if (!(neg1 ^ neg2)) {
if (s1.length() < s2.length()) {
String temp = s1;
s1 = s2;
s2 = temp;
}
} else if (neg1) {
if (s1.length() < s2.length() + 1) {
String temp = s1;
s1 = s2;
s2 = temp;
neg1 = false;
neg2 = true;
}
} else if (neg2) {
if (s1.length() + 1 < s2.length()) {
String temp = s1;
s1 = s2;
s2 = temp;
neg1 = true;
neg2 = false;
}
}
int[] lmax = new int[neg1 ? s1.length() - 1 : s1.length()];
for (int i = neg1 ? 1 : 0; i < lmax.length; ++i)
lmax[i] = s1.charAt(i) - '0';
int[] lmin = new int[neg2 ? s2.length() - 1 : s2.length()];
for (int i = neg2 ? 1 : 0; i < lmin.length; ++i)
lmin[i] = s2.charAt(i) - '0';
int i = lmax.length - 1, j = lmin.length - 1;
if (!(neg1 ^ neg2)) {
int[] carry = new int[1];
while (j >= 0) {
add(lmax, i, lmin[j], carry);
--i;
--j;
}
StringBuilder sb = new StringBuilder();
if (neg1)
sb.append('-');
if (carry[0] == 1)
sb.append(1);
for (i = 0; i < lmax.length; ++i)
sb.append(lmax[i]);
return sb.toString();
} else {
int flag = 0;
boolean neg = true;
if (i == j) {
flag = -1;
for (int k = 0; k <= i; ++k) {
if (lmax[k] > lmin[k]) {
flag = 0;
neg = neg1;
break;
} else if (lmax[k] < lmin[k]) {
flag = 1;
neg = neg2;
break;
}
}
}
if (flag == -1)
return "0";
if (flag == 1) {
int[] temp = lmax;
lmax = lmin;
lmin = temp;
}
while (j >= 0) {
minus(lmax, i, lmin[j]);
--i;
--j;
}
int L = 0;
for (i = 0; i < lmax.length; ++i) {
if (lmax[i] == 0) {
++L;
} else {
break;
}
}
StringBuilder sb = new StringBuilder();
if (neg)
sb.append('-');
for (i = L; i < lmax.length; ++i)
sb.append(lmax[i]);
return sb.toString();
}
}
static void add(int[] lmax, int i, int val, int[] carry) {
if (i == -1) {
carry[0] = 1;
return;
}
lmax[i] += val;
if (lmax[i] >= 10) {
lmax[i] = lmax[i] - 10;
add(lmax, --i, 1, carry);
}
}
static void minus(int[] max, int i, int val) {
max[i] -= val;
if (max[i] < 0) {
max[i] = max[i] + 10;
minus(max, --i, 1);
}
}
}
输入n个整数，输出其中最小的k个
题目描述
输入n个整数，输出其中最小的k个。
本题有多组输入样例，请使用循环读入，比如while(cin>>)等方式处理
输入描述:
第一行输入两个整数n和k
第二行输入一个整数数组
输出描述:
输出一个从小到大排序的整数数组
示例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.*;
import java.util.*;
public class Main{
public static void main(String[] args) throws Exception{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String content ;
while(null != (content = br.readLine())){
int num = Integer.parseInt(content);
for(int i = num/2;i>2;i--){
if(check(i) && check(num-i)){
System.out.println(i);
System.out.println(num-i);
break;
}
}
}
}
public static boolean check(int num){
for(int i = 2;i*i<=num;i++){
if(num%i == 0){
return false;
}
}
return true;
}
}
放苹果
题目描述
题目描述
把m个同样的苹果放在n个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？（用K表示）5，1，1和1，5，1 是同一种分法。
数据范围：0<=m<=10，1<=n<=10。
本题含有多组样例输入。
输入描述:
输入两个int整数
输出描述:
输出结果，int型
示例1
输入
7 3
输出
8
//把M个同样的苹果放在N个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？（用K表示）5，1，1和1，5，1 是同一种分法。
//输入
//每个用例包含二个整数M和N。0<=m<=10，1<=n<=10。
//样例输入
//7 3
//样例输出
//8
/**
* 计算放苹果方法数目
* 输入值非法时返回-1
* 1 <= m,n <= 10
* @param m 苹果数目
* @param n 盘子数目数
* @return 放置方法总数
*
*/
//public static int count(int m, int n)
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;
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[] s = str.split(" ");
int m = Integer.parseInt(s[0]);
int n = Integer.parseInt(s[1]);
System.out.println(count(m,n));
}
}
public static int count(int m,int n){
if(n == 1 || m == 0)return 1;
else if(n > m)return count(m,m);
else return count(m,n - 1) + count(m - n,n);
}
}
查找输入整数二进制中1的个数
题目描述
输入一个正整数，计算它在二进制下的1的个数。
注意多组输入输出！！！！！！
输入描述:
输入一个整数
输出描述:
计算整数二进制中1的个数
示例1
输入
5
输出
2
说明
5的二进制表示是101，有2个1
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){
int n = Integer.parseInt(str);
String s = Integer.toBinaryString(n);
int cnt = 0;
for(char c : s.toCharArray())
if(c == '1')
cnt++;
System.out.println(cnt);
}
}
}
DNA序列
题目描述
一个DNA序列由A/C/G/T四个字母的排列组合组成。G和C的比例（定义为GC-Ratio）是序列中G和C两个字母的总的出现次数除以总的字母数目（也就是序列长度）。在基因工程中，这个比例非常重要。因为高的GC-Ratio可能是基因的起始点。
给定一个很长的DNA序列，以及要求的最小子序列长度，研究人员经常会需要在其中找出GC-Ratio最高的子序列。
本题含有多组样例输入。
输入描述:
输入一个string型基因序列，和int型子串的长度
输出描述:
找出GC比例最高的子串,如果有多个输出第一个的子串
示例1
输入
AACTGTGCACGACCTGA
5
输出
GCACG
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
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 len = Integer.parseInt(br.readLine());
char[] c = str.toCharArray();
int max = 0;
int start = 0;
for(int i = 0; i < c.length - len; i++) {
int count = 0;
for(int j = 0; j < len; j++) {
if(c[i + j] == 'G' || c[i + j] == 'C')
count ++;
}
if(count > max) {
start = i;
max = count;
}
}
StringBuilder builder = new StringBuilder();
for(int i = start; i < start + len; i++) {
builder.append(c[i]);
}
System.out.println(builder.toString());
}
}
}
MP3光标位置
题目描述
MP3 Player因为屏幕较小，显示歌曲列表的时候每屏只能显示几首歌曲，用户要通过上下键才能浏览所有的歌曲。为了简化处理，假设每屏只能显示4首歌曲，光标初始的位置为第1首歌。
现在要实现通过上下键控制光标移动来浏览歌曲列表，控制逻辑如下：
歌曲总数<=4的时候，不需要翻页，只是挪动光标位置。
光标在第一首歌曲上时，按Up键光标挪到最后一首歌曲；光标在最后一首歌曲时，按Down键光标挪到第一首歌曲。
其他情况下用户按Up键，光标挪到上一首歌曲；用户按Down键，光标挪到下一首歌曲。
2. 歌曲总数大于4的时候（以一共有10首歌为例）：
特殊翻页：屏幕显示的是第一页（即显示第1 – 4首）时，光标在第一首歌曲上，用户按Up键后，屏幕要显示最后一页（即显示第7-10首歌），同时光标放到最后一首歌上。同样的，屏幕显示最后一页时，光标在最后一首歌曲上，用户按Down键，屏幕要显示第一页，光标挪到第一首歌上。
一般翻页：屏幕显示的不是第一页时，光标在当前屏幕显示的第一首歌曲时，用户按Up键后，屏幕从当前歌曲的上一首开始显示，光标也挪到上一首歌曲。光标当前屏幕的最后一首歌时的Down键处理也类似。
其他情况，不用翻页，只是挪动光标就行。
输入描述:
输入说明：
1 输入歌曲数量
2 输入命令 U或者D
本题含有多组输入数据！
输出描述:
输出说明
1 输出当前列表
2 输出当前选中歌曲
示例1
输入
10
UUUU
输出
7 8 9 10
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));
// Scanner sc = new Scanner(System.in);
String str = null;
while ((str = br.readLine()) != null) {
String str2 = br.readLine();
int num = Integer.parseInt(str);
char[] array = str2.toCharArray();
int current = 1;
int start = 1;
for (char one : array) {
if (num <= 4) {
if(one == 'U') {
if(current == 1) {
current = num;
}else {
current--;
}
}
else if(one == 'D') {
if(current == num) {
current = 1;
}else {
current++;
}
}
}
if(num > 4) {
if(one == 'U') {
if(current == 1) {
current = num;
start = num-3;
}else if(current == start) {
current--;
start--;
}else {
current--;
}
}else if(one == 'D') {
if(current == num) {
current = 1;
start = 1;
}else if(current == start+3) {
current++;
start++;
}else {
current++;
}
}
}
}
StringBuilder sb = new StringBuilder();
for(int i=1;i<=4;i++) {
if(num >=i) {
sb.append(start + i -1).append(" ");
}
}
System.out.println(sb.toString().trim());
System.out.println(current);
}
}
}
查找两个字符串a,b中的最长公共子串
题目描述
查找两个字符串a,b中的最长公共子串。若有多个，输出在较短串中最先出现的那个。
注：子串的定义：将一个字符串删去前缀和后缀（也可以不删）形成的字符串。请和“子序列”的概念分开！
本题含有多组输入数据！
输入描述:
输入两个字符串
输出描述:
返回重复出现的字符
示例1
输入
abcdefghijklmnop
abcsafjklmnopqrstuvw
输出
jklmnop
import java.io.*;
import java.util.*;
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 ss = br.readLine();
if(str.length()<ss.length()){
System.out.println(res(str,ss));
}else{
System.out.println(res(ss,str));
}
}
}
public static String res(String s,String c){
char[] ch1 = s.toCharArray();
char[] ch2 = c.toCharArray();
int[][] ins = new int[ch1.length + 1][ch2.length + 1];
int max = 0;
int start = 0;
for (int i = 0; i < ch1.length; i++) {
for (int j = 0; j < ch2.length; j++) {
if(ch1[i]==ch2[j]){
ins[i+1][j+1] = ins[i][j]+1;
if(ins[i+1][j+1]>max){
max = ins[i+1][j+1];
start = i-max;
}
}
}
}
return s.substring(start+1,start+max+1);
}
}
配置文件恢复
题目描述
有6条配置命令，它们执行的结果分别是：
| 命 令 |
执 行 |
| reset |
reset what |
| reset board |
board fault |
| board add |
where to add |
| board delete |
no board at all |
| reboot backplane |
impossible |
| backplane abort |
install first |
| he he |
unknown command |
注意：he he不是命令。
为了简化输入，方便用户，以“最短唯一匹配原则”匹配：
1、若只输入一字串，则只匹配一个关键字的命令行。例如输入：r，根据该规则，匹配命令reset，执行结果为：reset what；输入：res，根据该规则，匹配命令reset，执行结果为：reset what；
2、若只输入一字串，但本条命令有两个关键字，则匹配失败。例如输入：reb，可以找到命令reboot backpalne，但是该命令有两个关键词，所有匹配失败，执行结果为：unknown command
3、若输入两字串，则先匹配第一关键字，如果有匹配但不唯一，继续匹配第二关键字，如果仍不唯一，匹配失败。例如输入：r b，找到匹配命令reset board 和 reboot backplane，执行结果为：unkown command。
4、若输入两字串，则先匹配第一关键字，如果有匹配但不唯一，继续匹配第二关键字，如果唯一，匹配成功。例如输入：b a，无法确定是命令board add还是backplane abort，匹配失败。
5、若输入两字串，第一关键字匹配成功，则匹配第二关键字，若无匹配，失败。例如输入：bo a，确定是命令board add，匹配成功。
6、若匹配失败，打印“unknown command”
输入描述:
多行字符串，每行字符串一条命令
输出描述:
执行结果，每条命令输出一行
示例1
输入
reset
reset board
board add
board delet
reboot backplane
backplane abort
输出
reset what
board fault
where to add
no board at all
impossible
install first
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class Main {
public static void main(String[] args) throws IOException{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String str="";
StringBuilder sb=new StringBuilder();
String[] str1={"reset","reset board","board add","board delete","reboot backplane","backplane abort"};
Out:
while((str=br.readLine())!=null){
String[] str2=str.split(" ");
if(str2.length==1){
String cmd=str1[0];
for(int i=0;i<str2[0].length();i++){
if(str2[0].charAt(i)!=cmd.charAt(i)){
sb.append("unknown command").append("\n");
continue Out;
}
}
sb.append("reset what").append("\n");
}else if(str2.length==2){
if(str2[0].charAt(0)=='r'){
if((str2[0].equals("r")&&str2[1].equals("b"))||(str2[0].equals("re")&&str2[1].equals("b")))
sb.append("unknown command").append("\n");
else if(str2[0].length()<6 && str2[1].length()<6 && str2[0].equals(str1[1].substring(0,str2[0].length()))&&str2[1].equals(str1[1].substring(6,6+str2[1].length())))
sb.append("board fault").append("\n");
else if(str2[0].length()<7 && str2[1].length()<10 && str2[0].equals(str1[4].substring(0,str2[0].length()))&&str2[1].equals(str1[4].substring(7,7+str2[1].length())))
sb.append("impossible").append("\n");
else sb.append("unknown command").append("\n");}
else if(str2[0].charAt(0)=='b'){
if((str2[0].equals("b")&&str2[1].equals("a")))
sb.append("unknown command").append("\n");
else if(str2[0].length()<6 && str2[1].length()<4 && str2[0].equals(str1[2].substring(0,str2[0].length()))&&str2[1].equals(str1[2].substring(6,6+str2[1].length())))
sb.append("where to add").append("\n");
else if(str2[0].length()<6 && str2[1].length()<7 && str2[0].equals(str1[3].substring(0,str2[0].length()))&&str2[1].equals(str1[3].substring(6,6+str2[1].length())))
sb.append("no board at all").append("\n");
else if(str2[0].length()<10 && str2[1].length()<6 && str2[0].equals(str1[5].substring(0,str2[0].length()))&&str2[1].equals(str1[5].substring(10,10+str2[1].length())))
sb.append("install first").append("\n");
}else sb.append("unknown command").append("\n");
}
}
sb.deleteCharAt(sb.length()-1);
System.out.println(sb.toString());
}
}
24点游戏算法
题目描述
问题描述：给出4个1-10的数字，通过加减乘除，得到数字为24就算胜利
输入：
4个1-10的数字。[数字允许重复，但每个数字仅允许使用一次，测试用例保证无异常数字。
输出：
true or false
本题含有多组样例输入。
输入描述:
输入4个int整数
输出描述:
返回能否得到24点，能输出true，不能输出false
示例1
输入
7 2 1 10
输出
true
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[] numstrs = str.split(" ");
int[] nums = new int[4];
nums[0] = Integer.parseInt(numstrs[0]);
nums[1] = Integer.parseInt(numstrs[1]);
nums[2] = Integer.parseInt(numstrs[2]);
nums[3] = Integer.parseInt(numstrs[3]);
boolean flag = false;
for(int i = 0; i < 4; i++) {
if(is24(nums, 1 << i, nums[i])) {
flag = true;
break;
}
}
System.out.println(flag);
}
}
private static boolean is24(int[] nums, int stu, int val) {
if(val == 24) return true;
else if (stu == 7) return false;
for(int i = 0; i < 4; i++) {
int temp = 1 << i;
if ((temp & stu) == 0) {
temp |= stu;
if(is24(nums, temp, val + nums[i])
||is24(nums, temp, val - nums[i])
||is24(nums, temp, val * nums[i])
||(val % nums[i] == 0 && is24(nums, temp, val + nums[i])))
return true;
}
}
return false;
}
}
成绩排序
题目描述
查找和排序
题目：输入任意（用户，成绩）序列，可以获得成绩从高到低或从低到高的排列,相同成绩
都按先录入排列在前的规则处理。
例示：
jack 70
peter 96
Tom 70
smith 67
从高到低 成绩
peter 96
jack 70
Tom 70
smith 67
从低到高
smith 67
jack 70
Tom 70
peter 96
注：0代表从高到低，1代表从低到高
本题含有多组输入数据！
输入描述:
输入多行，先输入要排序的人的个数，然后分别输入他们的名字和成绩，以一个空格隔开
输出描述:
按照指定方式输出名字和成绩，名字和成绩之间以一个空格隔开
示例1
输入
3
0
fang 90
yang 50
ning 70
输出
fang 90
ning 70
yang 50
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/*
* 查找和排序
题目：输入任意（用户，成绩）序列，可以获得成绩从高到低或从低到高的排列,相同成绩
都按先录入排列在前的规则处理。
例示：
jack 70
peter 96
Tom 70
smith 67
从高到低 成绩
peter 96
jack 70
Tom 70
smith 67
从低到高
smith 67
jack 70
Tom 70
peter 96
注：0代表从高到低，1代表从低到高
*/
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.trim());
int bool=Integer.parseInt(br.readLine().trim());
String[] name =new String[n];
int[] score=new int[n];
for(int i=0;i<n;i++){
str=br.readLine().trim();
String[] temp= str.split(" ");
name[i]=temp[0];
score[i]=Integer.parseInt(temp[1]);
}
if(bool==0){ // 由高到低
for(int i=0;i<n;i++){
for(int j=0;j<n-1-i;j++){
if(score[j+1]>score[j]){
String na=name[j];
name[j]=name[j+1];
name[j+1]=na;
int t=score[j];
score[j]=score[j+1];
score[j+1]=t;
}
}
}
}else{ // 由低到高
for(int i=0;i<n;i++){
for(int j=0;j<n-1-i;j++){
if(score[j+1]<score[j]){
String na=name[j];
name[j]=name[j+1];
name[j+1]=na;
int t=score[j];
score[j]=score[j+1];
score[j+1]=t;
}
}
}
}
StringBuilder sb = new StringBuilder();
for(int i=0;i<n;i++) {
sb.append(name[i] + " ");
sb.append(score[i]);
// if(i!=(n-1)) {
// sb.append("\n");
// }
sb.append("\n");
}
sb.deleteCharAt(sb.length()-1);
System.out.println(sb.toString());
}
}
}
矩阵乘法
题目描述
如果A是个x行y列的矩阵，B是个y行z列的矩阵，把A和B相乘，其结果将是另一个x行z列的矩阵C。这个矩阵的每个元素是由下面的公式决定的
矩阵的大小不超过100*100
输入描述:
输入包含多组数据，每组数据包含：
第一行包含一个正整数x，代表第一个矩阵的行数
第二行包含一个正整数y，代表第一个矩阵的列数和第二个矩阵的行数
第三行包含一个正整数z，代表第二个矩阵的列数
之后x行，每行y个整数，代表第一个矩阵的值
之后y行，每行z个整数，代表第二个矩阵的值
输出描述:
对于每组输入数据，输出x行，每行z个整数，代表两个矩阵相乘的结果
示例1
输入
2
3
2
1 2 3
3 2 1
1 2
2 1
3 3
输出
14 13
10 11
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 x = Integer.parseInt(str);
int y = Integer.parseInt(br.readLine());
int z = Integer.parseInt(br.readLine());
int[][] matrix1 = new int[x][y];
int[][] matrix2 = new int[y][z];
for (int i = 0; i < x; i++) {
String[] params = br.readLine().split(" ");
for (int j = 0; j < y; j++) {
matrix1[i][j] = Integer.parseInt(params[j]);
}
}
for (int i = 0; i < y; i++) {
String[] params = br.readLine().split(" ");
for (int j = 0; j < z; j++) {
matrix2[i][j] = Integer.parseInt(params[j]);
}
}
StringBuilder ans = new StringBuilder();
for (int i = 0; i < x; i++) {
for (int j = 0; j < z; j++) {
int temp = 0;
for (int k = 0; k < y; k++) {
temp += matrix1[i][k] * matrix2[k][j];
}
ans.append(temp).append(" ");
}
ans.deleteCharAt(ans.length()-1).append("\n");
}
System.out.print(ans.toString());
}
}
}
矩阵乘法计算量估算
题目描述
矩阵乘法的运算量与矩阵乘法的顺序强相关。
例如：
A是一个50×10的矩阵，B是10×20的矩阵，C是20×5的矩阵
计算A*B*C有两种顺序：（（AB）C）或者（A（BC）），前者需要计算15000次乘法，后者只需要3500次。
编写程序计算不同的计算顺序需要进行的乘法次数。
本题含有多组样例输入！
输入描述:
输入多行，先输入要计算乘法的矩阵个数n，每个矩阵的行数，列数，总共2n的数，最后输入要计算的法则
计算的法则为一个字符串，仅由左右括号和大写字母（'A'~'Z'）组成，保证括号是匹配的且输入合法！
输出描述:
输出需要进行的乘法次数
示例1
输入
3
50 10
10 20
20 5
(A(BC))
输出
3500
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 br = new BufferedReader(new InputStreamReader(System.in));
// Scanner sc = new Scanner(System.in);
String str = null;
while ((str = br.readLine()) != null) {
int num = Integer.parseInt(str);
int [][] arr = new int[num][2];
for(int i = 0;i<num;i++) {
String [] sa = br.readLine().split(" ");
arr[i][0] = Integer.parseInt(sa[0]);
arr[i][1] = Integer.parseInt(sa[1]);
}
int n = arr.length -1;
char [] ca = br.readLine(). toCharArray();
Stack<Integer> stack = new Stack<>();
int sum = 0;
for(int i = ca.length - 1;i>=0;i--) {
char one = ca[i];
if(one == ')') {
stack.push(-1);
}else if(one == '(') {
int n1 = stack.pop();
int n2 = stack.pop();
sum+= arr[n1][0]*arr[n2][0]*arr[n2][1];
arr[n1][1] = arr[n2][1];
stack.pop();
stack.push(n1);
}else {
stack.push(n);
n--;
}
}
System.out.println(sum);
}
}
}
字符串通配符
题目描述
问题描述：在计算机中，通配符一种特殊语法，广泛应用于文件搜索、数据库、正则表达式等领域。现要求各位实现字符串通配符的算法。
要求：
实现如下2个通配符：
*：匹配0个或以上的字符（字符由英文字母和数字0-9组成，不区分大小写。下同）
？：匹配1个字符
输入：
通配符表达式；
一组字符串。
输出：
返回匹配的结果，正确输出true，错误输出false
本题含有多组样例输入！
输入描述:
先输入一个带有通配符的字符串，再输入一个需要匹配的字符串
输出描述:
返回匹配的结果，正确输出true，错误输出false
示例1
输入
te?t*.*
txt12.xls
输出
false
import java.io.*;
public class Main{
public static void main(String[] args) throws Exception{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String regx ;
while(null != (regx = br.readLine())){
String content = br.readLine();
System.out.println(match(content.toCharArray(),0,regx.toCharArray(),0));
}
}
public static boolean match(char[] content,int offsetContent,char[] regx,int offsetRegx){
while(offsetContent < content.length && offsetRegx < regx.length){
if('*' == regx[offsetRegx]){
if(offsetRegx == regx.length-1){
return true;
}else if(isMatch(content[offsetContent],regx[offsetRegx+1]) && match(content,offsetContent,regx,offsetRegx+1)){
return true;
}else{
offsetContent++;
}
}else if('?' == regx[offsetRegx] || content[offsetContent] == regx[offsetRegx]){
offsetContent++;
offsetRegx++;
}else{
return false;
}
}
return (offsetContent==content.length)&&(offsetRegx==regx.length);
}
public static boolean isMatch(char contentChar,char regxChar){
return '*'==regxChar || '?'==regxChar || contentChar == regxChar;
}
}
百钱买百鸡问题
题目描述
公元前五世纪，我国古代数学家张丘建在《算经》一书中提出了“百鸡问题”：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？
详细描述：
接口说明
原型：
int GetResult(vector &list)
输入参数：
无
输出参数（指针指向的内存区域保证有效）：
list 鸡翁、鸡母、鸡雏组合的列表
返回值：
-1 失败
0 成功
输入描述:
输入任何一个整数，即可运行程序。
输出描述:
示例1
输入
1
输出
0 25 75
4 18 78
8 11 81
12 4 84
public class Main{
public static void main(String[] args) {
for (int x=0;x<100;x++){
for (int y=0;y<100;y++){
if (14*x+8*y==200){
System.out.println(x+" "+y+" "+(100-x-y));
}
}
}
}
}
