题目标签
| 1 | 2 | 3 | 4 | 5 | |||||
| 最大公约数 | 互质的数 | 进制转换 | 二叉树结点 | 元素距离 | |||||
| 6 | 7 | 8 | 9 | 10 | |||||
| 最长的递增序列 | 洁净数 | 梅花桩 | 元音字母 | 积木搭城堡 |
1
问题描述
70044与113148的最大公约数是多少？
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
package 最大公约数;
import java.math.BigInteger;
public class Main {
public static void main(String[] args) {
//70044与113148的最大公约数是多少？
BigInteger a = new BigInteger("70044");
BigInteger b = new BigInteger("113148");
System.out.println(a.gcd(b));
}
}
2
问题描述
不超过19000的正整数中，与19000互质的数的个数是多少？
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
package 互质的数;
import java.util.ArrayList;
public class Main {
//1和任何除0以外自然数都互质 。
public static void main(String[] args) {
//不超过19000的正整数中，与19000互质的数的个数是多少？
int count = 0;
for (int i = 1; i <= 19000; i++) {
ArrayList<Integer> list = new ArrayList<Integer>();
int temp = i;
for (int j = 1; j <= temp; j++) {
//求出公因数存入集合
if (19000 % j == 0 && temp % j == 0) {
list.add(j);
}
}
//只有1是公因数,才是互质
if (list.size() == 1) {
System.out.println(temp+" "+list+" count= "+(++count));
}
}
}
}
3
问题描述
请问十六进制数1949对应的十进制数是多少？请特别注意给定的是十六进制，求的是十进制。
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
package 进制转换;
public class Main {
public static void main(String[] args) {
// 请问十六进制数1949对应的十进制数是多少？请特别注意给定的是十六进制，求的是十进制。
System.out.println(Integer.valueOf("1949", 16));
}
}
4
问题描述
一棵10层的二叉树，最多包含多少个结点？
注意当一棵二叉树只有一个结点时为一层。
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
package 进制转换;
public class Main {
public static void main(String[] args) {
// 请问十六进制数1949对应的十进制数是多少？请特别注意给定的是十六进制，求的是十进制。
System.out.println(Integer.valueOf("1949", 16));
}
}
5
问题描述
在数列 a_1, a_2, ..., a_n中，定义两个元素 a_i 和 a_j 的距离为 |i-j|+|a_i-a_j|，即元素下标的距离加上元素值的差的绝对值，其中 |x| 表示 x 的绝对值。
给定一个数列，请问找出元素之间最大的元素距离。
输入格式
输入的第一行包含一个整数 n。
第二行包含 n 个整数 a_1, a_2, ..., a_n，相邻的整数间用空格分隔，表示给定的数列。
输出格式
输出一行包含一个整数，表示答案。
样例输入
5
9 4 2 4 7
样例输出
9
样例说明
a_1 和 a_3 的距离为 |1-3|+|9-2|=9。
评测用例规模与约定
对于 50% 的评测用例，2 <= n <= 100，0 <= 数列中的数 <= 1000。
对于所有评测用例，2 <= n <= 1000，0 <= 数列中的数 <= 10000。
package 元素距离;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sr = new Scanner(System.in);
int n = sr.nextInt();
int[] arr = new int[n];
int max = Integer.MIN_VALUE;
for (int i = 0; i < arr.length; i++) {
arr[i] = sr.nextInt();
}
sr.close();
for (int i = 0; i < arr.length; i++) {
for (int j = i; j < arr.length; j++) {
max = Math.max(max, Math.abs((i+1)-(j+1))+Math.abs(arr[i]-arr[j]));
}
}
System.out.println(max);
}
}
6
问题描述
在数列 a[1], a[2], ..., a[n] 中，如果 a[i] < a[i+1] < a[i+2] < ... < a[j]，则称 a[i] 至 a[j] 为一段递增序列，长度为 j-i+1。
给定一个数列，请问数列中最长的递增序列有多长。
输入格式
输入的第一行包含一个整数 n。
第二行包含 n 个整数 a[1], a[2], ..., a[n]，相邻的整数间用空格分隔，表示给定的数列。
输出格式
输出一行包含一个整数，表示答案。
样例输入
7
5 2 4 1 3 7 2
样例输出
3
评测用例规模与约定
对于 50% 的评测用例，2 <= n <= 100，0 <= 数列中的数 <= 1000。
对于所有评测用例，2 <= n <= 1000，0 <= 数列中的数 <= 10000。
package 最长递增序列;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sr = new Scanner(System.in);
int n = sr.nextInt();
int[] arr = new int[n];
int max = Integer.MIN_VALUE;//最长递增序列
for (int i = 0; i < arr.length; i++) {
arr[i] = sr.nextInt();
}
sr.close();
//遍历起点
for (int i = 0; i < arr.length; i++) {
int step = 1;//递增序列为1
//从i这个起点出发,往下遍历看看是否递增.递增step++,否则就继续循环i
for (int j = i; j < arr.length-1; j++) {
if (arr[j]<arr[j+1]) {
step ++;
}else {
break;
}
}
//选取最长递增序列
max = Math.max(max, step);
}
System.out.println(max);
}
}
7
问题描述
小明非常不喜欢数字 2，包括那些数位上包含数字 2 的数。如果一个数的数位不包含数字 2，小明将它称为洁净数。
请问在整数 1 至 n 中，洁净数有多少个？
输入格式
输入的第一行包含一个整数 n。
输出格式
输出一行包含一个整数，表示答案。
样例输入
30
样例输出
18
评测用例规模与约定
对于 40% 的评测用例，1 <= n <= 10000。
对于 80% 的评测用例，1 <= n <= 100000。
对于所有评测用例，1 <= n <= 1000000。
package 洁净数;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sr = new Scanner(System.in);
int n = sr.nextInt();
int count = 0;
for (int i = 1; i <= n; i++) {
if (!(i+"").contains("2")) {
count++;
System.out.println(i);
}
}
System.out.println(count);
}
}
8
问题描述
小明每天都要练功，练功中的重要一项是梅花桩。
小明练功的梅花桩排列成 n 行 m 列，相邻两行的距离为 1，相邻两列的距离也为 1。
小明站在第 1 行第 1 列上，他要走到第 n 行第 m 列上。小明已经练了一段时间，他现在可以一步移动不超过 d 的距离（直线距离）。
小明想知道，在不掉下梅花桩的情况下，自己最少要多少步可以移动到目标。
输入格式
输入的第一行包含两个整数 n, m，分别表示梅花桩的行数和列数。
第二行包含一个实数 d（最多包含一位小数），表示小明一步可以移动的距离。
输出格式
输出一个整数，表示小明最少多少步可以到达目标。
样例输入
3 4
1.5
样例输出
3
评测用例规模与约定
对于 30% 的评测用例，2 <= n, m <= 20，1 <= d <= 20。
对于 60% 的评测用例，2 <= n, m <= 100，1 <= d <= 100。
对于所有评测用例，2 <= n, m <= 1000，1 <= d <= 100。
package 梅花桩;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
//最短走法:
//1.斜着走走啊走,一直摸到边
//2.摸着边了延边走
Scanner sr = new Scanner(System.in);
int n = sr.nextInt();
int m = sr.nextInt();
double d = sr.nextDouble();
int step = 0;
int x = 1,y = 1;
//直接一步登天
if (n*n+m*m <= (d*d)) {
System.out.println(1);
return;
}
//最优先斜着走,一直摸到横竖随便一条边
while (x!=n && y!=m) {
//d丢失精度后是最大能跳距离
x+=(int)d;
y+=(int)d;
step++;
}
//摸到行了,往右走
if (x == n) {
while (y<m) {
y += (int)d;
step++;
}
}
//摸到列了.向下走
if (y == m) {
while (x<n) {
x += (int)d;
step++;
}
}
System.out.println(step);
}
}
9
问题描述
给定一个单词，请计算这个单词中有多少个元音字母，多少个辅音字母。
元音字母包括 a, e, i, o, u，共五个，其他均为辅音字母。
输入格式
输入一行，包含一个单词，单词中只包含小写英文字母。
输出格式
输出两行，第一行包含一个整数，表示元音字母的数量。
第二行包含一个整数，表示辅音字母的数量。
样例输入
lanqiao
样例输出
4
3
评测用例规模与约定
对于所有评测用例，单词中的字母个数不超过100。
package 元音字母;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sr = new Scanner(System.in);
StringBuilder sb = new StringBuilder(sr.next());
sr.close();
int yuan = 0;
for (int i = 0; i < sb.length(); i++) {
if (yuan(sb.charAt(i))) {
yuan++;
}
}
System.out.println(yuan);
System.out.println(sb.length()-yuan);
}
private static boolean yuan(char charAt) {
if (charAt=='a' || charAt == 'e' || charAt == 'i' || charAt == 'o' || charAt == 'u')
return true;
else
return false;
}
}
10
问题描述
小明用积木搭了一个城堡。
为了方便，小明在搭的时候用的是一样大小的正方体积本，搭在了一个 n 行 m 列的方格图上，每个积木正好占据方格图的一个小方格。
当然，小明的城堡并不是平面的，而是立体的。小明可以将积木垒在别的积木上面。当一个方格上的积木垒得比较高时，就是一个高塔，当一个方格上没有积木时，就是一块平地。
小明的城堡可以用每个方格上垒的积木层数来表示。例如，下面就表示一个城堡。
9 3 3 1
3 3 3 0
0 0 0 0
这个城堡南面和东面都有空地，西北面有一个大房子，在西北角还有一个高塔，东北角有一个车库。
现在，格格巫要来破坏小明的城堡，他施了魔法水淹小明的城堡。
如果水的高度为1，则紧贴地面的那些积木要被水淹，在上面的例子中，有7块积木要被水淹。
如果水的高度为2，则更多积木要被水淹，在上面的例子中，有13块积木要被水淹。
给定小明的城堡图，请问，水的高度依次为1, 2, 3, ...., H 时，有多少块积木要被水淹。
输入格式
输入的第一行包含两个整数 n, m。
接下来 n 行，每行 m 个整数，表示小明的城堡中每个位置积木的层数。
接下来包含一个整数 H，表示水高度的上限。
输出格式
输出 H 行，每行一个整数。第 i 的整数表示水的高度为 i 时被水淹的积木数量。
样例输入
3 4
9 3 3 1
3 3 3 0
0 0 0 0
10
样例输出
7
13
19
20
21
22
23
24
25
25
评测用例规模与约定
对于 40% 的评测用例，1 <= n, m <= 100，1 <= H <= 100，积木层数不超过100；
对于 70% 的评测用例，1 <= n, m <= 1000，1 <= H <= 1000，积木层数不超过1000；
对于所有评测用例，1 <= n, m <= 1000，1 <= H <= 100000，积木层数不超过1000000000。
package 积木城堡;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sr = new Scanner(System.in);
int n = sr.nextInt();
int m = sr.nextInt();
//存储没有被湮没的城堡
Queue<Integer> que = new LinkedList<Integer>();
for (int i = 0; i < n*m; i++) {
int num = sr.nextInt();
if (num > 0)
que.add(num);
}
//高度
int h = sr.nextInt();
sr.close();
int sum = 0;//淹没城堡层数
for (int i = 0; i < h; i++) {
//队列里面是没有被淹没的,都会被淹没一层
int len = que.size();
sum += len;
System.out.println(sum);
//淹没一层,丢掉被完全淹没的城堡
for (int j = 0; j < len; j++) {
int temp = que.poll()-1;
if (temp > 0)
que.add(temp);
}
}
}
}
9578
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
