第一题 单位变换
题目
【问题描述】
在计算机存储中,15.125GB是多少MB?
【答案提交】
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
思路
1G=1024M
第二题 约数个数
/*【问题描述】
1200000有多少个约数(只计算正约数)。
【答案提交】
这是一道结果填空的题,你只需要算出结果后提交即可。
本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
* */
public class Main{
public static void main(String[] args) {
int count = 0;
for (int i = 1; i <= 1200000; i++) {
if(1200000 % i == 0){
count++;
}
}
System.out.println(count);//96
}
}
第三题 叶结点数
/*【【问题描述】
一棵包含有2019个结点的二叉树,最多包含多少个叶结点?
【答案提交】
这是一道结果填空的题,你只需要算出结果后提交即可。
本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
* */
public class Main{
public static void main(String[] args) {
//n=n0+n1+n2,为使叶子节点数(n0)最多,必须n1最小,设为0,而n0=n2+1
//
//得n2=(2019-1)/2=1009
//
//所以n0=1010
//也可以找规律
/*
结点数 最多叶子节点数
1 1
2 1
3 2
4 2
5 3
6 3
7 4
8 4
.....
2019 1010 ----> answer
2020 1020
*/
}
}
第四题 数字9
import java.util.Arrays;
/*
【问题描述】
在1至2019中,有多少个数的数位中包含数字9?
注意,有的数中的数位中包含多个9,这个数只算一次。例如,1999这个数包含数字9,在计算时只是算一个数。
【答案提交】
这是一道结果填空的题,你只需要算出结果后提交即可。
本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
* */
public class Main{
static int cnt = 1;
public static void main(String[] args) {
for (int i = 10; i <= 2019; i++) {
if(isContain(i)){
cnt++;
// System.out.println(cnt); 打印出来检查一下
}
}
System.out.println(cnt);//544
}
private static boolean isContain(int num) {
String str = num+"";
for (int i = 0; i < str.length(); i++) {
if(str.charAt(i) == '9'){
return true;
}
}
return false;
}
}
第五题 数位递增的数
import java.util.Scanner;
/*
题目
【问题描述】
一个正整数如果任何一个数位不大于右边相邻的数位,则称为一个数位递增的数,
例如1135是一个数位递增的数,而1024不是一个数位递增的数。
给定正整数 n,请问在整数 1 至 n 中有多少个数位递增的数?
【输入格式】
输入的第一行包含一个整数 n。
【输出格式】
输出一行包含一个整数,表示答案。
【样例输入】
30
【样例输出】
26
【评测用例规模与约定】
对于 40% 的评测用例,1 <= n <= 1000。
对于 80% 的评测用例,1 <= n <= 100000。
对于所有评测用例,1 <= n <= 1000000。 10^6 O(n^2)以下的时间复杂度
O(nlogn)
O(n)
O(logn)
* */
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String str = "";
int cnt = 0;
boolean flag = true;
for (int i = 1; i <= n; i++) {
str += i;
for (int j = 0; j < str.length() - 1; j++) {
if (str.charAt(j) > str.charAt(j + 1)) {
flag = false;
break;
}
}
if(flag){
cnt++;
}
flag = true;
str="";
}
System.out.println(cnt);
sc.close();
}
}
第六题 递增三元组
import java.util.Scanner;
/*
【问题描述】
在数列 a[1], a[2], …, a[n] 中,如果对于下标 i, j, k 满足 0<i<j<k<n+1 且 a[i]<a[j]<a[k],
则称 a[i], a[j], a[k] 为一组递增三元组,a[j]为递增三元组的中心。给定一个数列,请问数列中有
多少个元素可能是递增三元组的中心。
【输入格式】
输入的第一行包含一个整数 n。
第二行包含 n 个整数 a[1], a[2], …, a[n],相邻的整数间用空格分隔,表示给定的数列。
【输出格式】
输出一行包含一个整数,表示答案。
【样例输入】
5
1 2 5 3 5
【样例输出】
2
【样例说明】
a[2] 和 a[4] 可能是三元组的中心。
【评测用例规模与约定】
对于 50% 的评测用例,2 <= n <= 100,0 <= 数列中的数 <= 1000。
对于所有评测用例,2 <= n <= 1000,0 <= 数列中的数 <= 10000。
* */
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] arr = new int[n];
int[] res = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = sc.nextInt();
}
int tmp;
int cur = 0;
while (cur < n) {
for (int i = cur + 1; i < n; i++) {
if (arr[cur] < arr[i]) {
tmp = i;
//判断后面有没有比tmp位置的数字要大的
for (int j = i + 1; j < n; j++) {
if (arr[j] > arr[tmp]) {
res[tmp] = 1;
break;
}
}
}
}
cur++;
}
int cnt = 0;
for (int i = 0; i < res.length; i++) {
cnt += res[i];
}
System.out.println(cnt);
sc.close();
}
}
第七题 音节判断
import java.util.Scanner;
/**
* 【问题描述】
* 小明对类似于 hello 这种单词非常感兴趣,这种单词可以正好分为四段,第一段由一个或
* 多个辅音字母组成,第二段由一个或多个元音字母组成,第三段由一个或多个辅音字母组成,
* 第四段由一个或多个元音字母组成。
* 给定一个单词,请判断这个单词是否也是这种单词,如果是请输出yes,否则请输出no。
* 元音字母包括 a, e, i, o, u,共五个,其他均为辅音字母。
* 【输入格式】
* 输入一行,包含一个单词,单词中只包含小写英文字母。
* 【输出格式】
* 输出答案,或者为yes,或者为no。
* 【样例输入】
* lanqiao
* 【样例输出】
* yes
* 【样例输入】
* world
* 【样例输出】
* no
* 【评测用例规模与约定】
* 对于所有评测用例,单词中的字母个数不超过100。
*/
public class Main{
public static void main(String[] args) {
//hello
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
boolean f1,f2,f3,f4;
boolean need = false;//需要元音吗?
int cur = 0;
char[] chs = str.toCharArray();
if(!isYuan(chs[0])){
f1 =true;
need = true;
}else {
System.out.println("no");
System.exit(0);
}
int yuan = 0;
int fu = 1;
while(cur<str.length()){
if(need && isYuan(chs[cur])){
f2 = true;
need = false;
yuan++;
}
if(!need && !isYuan(chs[cur])){
f3 = true;
need = true;
fu++;
}
cur++;
}
if(yuan==2 && fu == 2){
System.out.println("yes");
}else
System.out.println("no");
sc.close();
}
private static boolean isYuan(char ch) {
return ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u';
}
}
第八题 长草
import java.util.LinkedList;
import java.util.Scanner;
/**
* 【问题描述】
* 小明有一块空地,他将这块空地划分为 n 行 m 列的小块,每行和每列的长度都为 1。
* 小明选了其中的一些小块空地,种上了草,其他小块仍然保持是空地。
* 这些草长得很快,每个月,草都会向外长出一些,如果一个小块种了草,则
* 它将向自己的上、下、左、右四小块空地扩展,这四小块空地都将变为有草的小块。
* 请告诉小明,k 个月后空地上哪些地方有草。
* 【输入格式】
* 输入的第一行包含两个整数 n, m。
* 接下来 n 行,每行包含 m 个字母,表示初始的空地状态,字母之间没有空格。如果为小数点,表示为空地,如果字母为 g,表示种了草。
* 接下来包含一个整数 k。
* 【输出格式】
* 输出 n 行,每行包含 m 个字母,表示 k 个月后空地的状态。如果为小数点,表示为空地,如果字母为 g,表示长了草。
* 【样例输入】
* 4 5
* .g...
* .....
* ..g..
* .....
* 2
* 【样例输出】
* gggg.
* gggg.
* ggggg
* .ggg.
* 【评测用例规模与约定】
* 对于 30% 的评测用例,2 <= n, m <= 20。
* 对于 70% 的评测用例,2 <= n, m <= 100。
* 对于所有评测用例,2 <= n, m <= 1000,1 <= k <= 1000。
*/
public class Main {
static final int[] dx = {1, 0, -1, 0};
static final int[] dy = {0, 1, 0, -1};
static Scanner sc;
static int[][] vis = new int[1000][1000];
static int N, M, K;
public static void main(String[] args){
sc = new Scanner(System.in);
N = sc.nextInt();
M = sc.nextInt();
sc.nextLine();
LinkedList<Block> q = new LinkedList<Block>();
for (int i = 0; i < N; i++) {
String line = sc.nextLine();
for (int j = 0; j < M; j++) {
if (line.charAt(j) == 'g') {
q.addLast(new Block(i, j, 0));
vis[i][j] = 1;
}
}
}
K = sc.nextInt();
while (!q.isEmpty()) {
Block b = q.removeFirst();
int month = b.month;
if (month < K) {
for (int i = 0; i <= 3; i++) {
int nx = b.i + dx[i];
int ny = b.j + dy[i];
if (0 <= nx && nx < N && 0 <= ny && ny < M && vis[nx][ny] == 0) {
vis[nx][ny] = 1;
q.addLast(new Block(nx, ny, month + 1));
}
}
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (vis[i][j] == 1) System.out.print('g');
else System.out.print('.');
}
System.out.print('\n');
}
}
//草地上的一块
private static class Block {
int i;
int j;
int month;
public Block(int i, int j, int month) {
this.i = i;
this.j = j;
this.month = month;
}
}
}
第九题 序列计数
import java.util.*;
/**
* 【问题描述】
* 小明想知道,满足以下条件的正整数序列的数量:
* 1. 第一项为 n;
* 2. 第二项不超过 n;
* 3. 从第三项开始,每一项小于前两项的差的绝对值。
* 请计算,对于给定的 n,有多少种满足条件的序列。
* 【输入格式】
* 输入一行包含一个整数 n。
* 【输出格式】
* 输出一个整数,表示答案。答案可能很大,请输出答案除以10000的余数。
* 【样例输入】
* 4
* 【样例输出】
* 7
* 【样例说明】
* 以下是满足条件的序列:
* 4 1
* 4 1 1
* 4 1 2
* 4 2
* 4 2 1
* 4 3
* 4 4
* 【评测用例规模与约定】
* 对于 20% 的评测用例,1 <= n <= 5;
* 对于 50% 的评测用例,1 <= n <= 10;
* 对于 80% 的评测用例,1 <= n <= 100;
* 对于所有评测用例,1 <= n <= 1000。
*/
public class Main {
static int cnt = 0;
static int[][] memo;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
long start = System.currentTimeMillis();
memo = new int[n + 1][n + 1];
for (int i = 0; i < n + 1; i++) {
Arrays.fill(memo[i], -1);
}
System.out.println(dfs(n, n));
long e = System.currentTimeMillis();
System.out.println(e - start + "ms");
sc.close();
}
private static int dfs(int n, int range) {
if (memo[n][range] != -1) {
return memo[n][range];
}
if(range ==0 || range == 1)
return 1;
int res = 0;
for (int i = 1; i < range; i++) {
res += dfs(i, Math.abs(i - n));
res %= 10000;
}
memo[n][range] = res + 1;
return res + 1;
}
/*
private static int bfs(int n, int n_1) {
int cnt = 0;
Queue<Integer> que = new LinkedList<>();
C = n + 1;
que.add(n * C + n_1);
while (!que.isEmpty()) {
int poll = que.remove();
n = poll / C;
n_1 = poll % C;
if (n_1 != 0 && n_1 != 1) {
for (int i = 1; i < n_1; i++) {
int i_1 = Math.abs(n - i);
que.add(i * C + i_1);
cnt++;
}
}
}
return cnt + 1;//还有一种是 n n 的两个数
}*/
}
第十题 晚会节目单
/**
* 第十题 晚会节目单
* 题目
* 【问题描述】
* 小明要组织一台晚会,总共准备了 n 个节目。然后晚会的时间有限,他只能最终选择其中的 m 个节目。
* 这 n 个节目是按照小明设想的顺序给定的,顺序不能改变。
* 小明发现,观众对于晚会的喜欢程度与前几个节目的好看程度有非常大的关系,
* 他希望选出的第一个节目尽可能好看,在此前提下希望第二个节目尽可能好看,依次类推。
* 小明给每个节目定义了一个好看值,请你帮助小明选择出 m 个节目,满足他的要求。
* 【输入格式】
* 输入的第一行包含两个整数 n, m ,表示节目的数量和要选择的数量。
* 第二行包含 n 个整数,依次为每个节目的好看值。
* 【输出格式】
* 输出一行包含 m 个整数,为选出的节目的好看值。
* 【样例输入】
* 5 3
* 3 1 2 5 4
* 【样例输出】
* 3 5 4
* 【样例说明】
* 选择了第1, 4, 5个节目。
* 【评测用例规模与约定】
* 对于 30% 的评测用例,1 <= n <= 20;
* 对于 60% 的评测用例,1 <= n <= 100;
* 对于所有评测用例,1 <= n <= 100000,0 <= 节目的好看值 <= 100000。
*/
public class Main {
public static void main(String[] args) {
}
}