1、在计算机存储中，15.125GB是多少MB？ 15488
2、1200000有多少个约数 96
3、一棵包含有2019个结点的二叉树，最多包含多少个叶结点？ 1010
4、在1至2019中，有多少个数的数位中包含数字9？ 544
1. 1GB=1024MB 2.暴力查询，96个 3.第一步、将2019除以2，得到1009，即可知从1010到1023为叶子节点，1024到2019为叶子结点，共1010个叶结点（下图） 4.同样暴力查询，得出结果是544
5、
【问题描述】
一个正整数如果任何一个数位不大于右边相邻的数位，则称为一个数位递增的数，例如1135是一个数位递增的数，而1024不是一个数位递增的数。给定正整数 n，请问在整数 1 至 n 中有多少个数位递增的数？
【输入格式】输入的第一行包含一个整数 n。
【输出格式】输出一行包含一个整数，表示答案。
【样例输入】30
【样例输出】26
题目思路
第一步：这里直接可以用暴力循环1-n
第二步：转化为字符串的形式然后单个字符进行比较，输出所求的个数
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 n = Integer.parseInt(br.readLine());
int ans = 9;
for (int i = 10; i <= n; i++) {
String str = new String(i+"");
Boolean sign =true;
char[] array = str.toCharArray();
for (int j = 1; j < array.length; j++) {
if(Integer.parseInt(array[j]+"")>=Integer.parseInt(array[j-1]+"")){
sign = true;
continue;
}else {
sign = false;
break;
}
}
if (sign==true) {
ans++;
// System.out.print(str + "\t");
}
}
// System.out.println();
System.out.println(ans);
}
}
6、
**【问题描述】**
在数列 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 ≤ a[i] ≤ 1000。
对于所有评测用例，2 ≤ n ≤ 1000，0 ≤ a[i] ≤ 10000。
**解题思路**
第一步：把数据存到数组
第二步：暴力查询三次循环，找到一个符合要求的j，这里如果有符合条件的话k可以直接跳出循环
第三部：要输出的是索引值，这里可以用桶排序的方法计数
**代码**
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main2 {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int number = Integer.parseInt(br.readLine());
int[] ans=new int[10001];
String[] array = br.readLine().split(" ");
int[] a = new int[number];
for (int i = 0; i < number; i++) {
a[i]=Integer.parseInt(array[i]+"");
}
for (int i = 0; i < number; i++) {
for (int j = i+1; j < number; j++) {
for (int k = j+1; k < number; k++) {
if (a[i]<a[j]&&a[j]<a[k]){
ans[j]=1;
break;
}
}
}
}
for (int i = 0; i < 1001; i++) {
if(ans[i]>0){
System.out.print(i+1+" ");
}
}
}
}
7、
**【问题描述】**
小明对类似于 hello 这种单词非常感兴趣，这种单词可以正好分为四段，
第一段由一个或多个辅音字母组成，第二段由一个或多个元音字母组成，
第三段由一个或多个辅音字母组成，第四段由一个或多个元音字母组成。
给定一个单词，请判断这个单词是否也是这种单词，如果是请输出yes，否则请输出no。
元音字母包括 a, e, i, o, u，共五个，其他均为辅音字母。
**【输入格式】**
一个单词，单词中只包含小写英文字母。
**【输出格式】**
输出答案，yes 或 no
**【样例输入1】**
lanqiao
**【样例输出1】**
yes
**【样例输入2】**
world
**【样例输出2】**
no
**【评测用例规模与约定】**
对于所有评测用例，单词中的字母个数不超过100。
**思路**
第一步：可以把它转为01字符串，比如说hello就是01001
第二步：判断只要从0到1或者从1到0就说明有转变，三次即为题目所求
**代码**
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main3 {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = br.readLine();
char[] values = str.toCharArray();
for (int i = 0; i < values.length; i++) {
if(values[i]=='a'||values[i]=='e'||values[i]=='i'||values[i]=='o'||values[i]=='u'){
values[i]='1';
}else {
values[i]='0';
}
}
int times=0;
for (int i = 1; i < values.length; i++) {
if((values[i]=='1'&&values[i-1]=='0')||(values[i]=='0'&&values[i-1]=='1')){
times++;
}
}
if (times==3){
System.out.println("yes");
}else{
System.out.println("no");
}
}
}8、
【问题描述】
小明有一块空地，他将这块空地划分为 n 行 m 列的小块，每行和每列的长度都为 1。
小明选了其中的一些小块空地，种上了草，其他小块仍然保持是空地。
这些草长得很快，每个月，草都会向外长出一些，
如果一个小块种了草，则它将向自己的上、下、左、右四小块空地扩展，这四小块空地都将变为有草的小块。
请告诉小明，k 个月后空地上哪些地方有草。
【输入格式】
第一行包含两个整数 n, m。
接下来 n 行，每行包含 m 个字母，表示初始的空地状态，字母之间没有空格。（ . 表示空地，g 表示草地）
接下来包含一个整数 k。
【输出格式】
输出 n 行，每行包含 m 个字母，表示 k 个月后空地的状态。如果为小数点，表示为空地，如果字母为 g，表示长了草。
【样例输入】
4 5
.g... 01000
..... 00000
..g.. 00100
..... 00000
【样例输出】
gggg.
gggg.
ggggg
.ggg.
【评测用例规模与约定】
对于 30% 的评测用例，2 ≤ n, m ≤ 20。
对于 70% 的评测用例，2 ≤ n, m ≤ 100。
对于所有评测用例，2 ≤ n, m ≤ 1000，1 ≤ k ≤ 1000。
题目思路
第一步：将他转为二维数组来解决
第二步：同样可以转为01字串，这里要注意改动的顺序，如果单纯搜索到一个g就上下左右改动会影响下一次操作。
第三步：用一个数组来记录有草的地方，这里我用了一个string数组 “i-j”的形式存储，调用函数grass来铺草。一遍查找一遍铺 和 全部记下来之后在铺 效果是不一样的
第四步：这里的二维数组有一个技巧，就是申请数组空间时多一层外围，这样就不用考虑row-1，row+1，column+1这些的数组索引会越界了。
参考代码
public class Main4 {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] values1 = br.readLine().split(" ");
int n = Integer.parseInt(values1[0]);
int m = Integer.parseInt(values1[1]);
String[][] grass = new String[n+2][m+2];
String[] sign = new String[n*m];
int index=0;
for (int i = 0; i < n; i++) {
String str = br.readLine();
String[] temp = str.split("");
for (int j = 0; j <temp.length ; j++) {
grass[i+1][j+1] = temp[j];
}
}
int times = Integer.parseInt(br.readLine());
for (int k = 0; k < times; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (grass[i][j].equals("g")){
sign[index++]=i+"-"+j;
}
}
}
grass(grass,sign);
}
for (int i =1; i < n+1; i++) {
for (int j = 1; j < m+1; j++) {
System.out.print(grass[i][j]);
}
System.out.println();
}
System.out.println();
}
public static void grass(String[][] grass,String[] sign){
int index=0;
while (sign[index]!=null){
String[] values = sign[index].split("-");
int row = Integer.parseInt(values[0]);
int column = Integer.parseInt(values[1]);
grass[row-1][column]="g";
grass[row+1][column]="g";
grass[row][column-1]="g";
grass[row][column+1]="g";
index++;
}
}
}
9//未解答
小明想知道，满足以下条件的正整数序列的数量：
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。
京公网安备 11010502036488号