java蓝桥11-20题总结
文章目录
-
- 11.排序
-
- 1.代码
- 2.知识点
-
- 冒泡排序
- 12.跑步锻炼
-
- 1.代码
- 13.蛇形填数
-
- 1.代码
- 14.递增序列
-
- 1.代码
- 15.A+B（OJ示例题目）
- 16.杨辉三角形
-
- 1.代码
- 2.知识点
- 17.货物
-
- 1.代码
- 18.九进制转十进制
-
- 1.代码
- 19.等差素数列
-
- 1.代码
- 20.七段码
11.排序
1.代码
package lanqiao11_20;
public class Sort_11 {
public static void main(String[] args) {
//思路1:要求字典序最小，那肯定要尽量让字母从a开始挨个出现 —— a,b,c,d.....
//思路2:冒泡排序中，如果一个数组是完全倒序，则需要的交换的次数最多,尽可能选用完全倒序的数组，可以使字母数尽可能少
//思路3:完全倒序的数组，用冒泡排序一共要交换 n*(n-1)/2 次 —— (n-1) + (n-2) + ... + 3 + 2 + 1 , 等差数列求和公式
//思路4:解方程 n*(n-1)/2 = 100, 得 n ~ 14.65 ,所以字母最少为15个
//思路5: 15个字母从 a 开开始，依次是 a,b,c,d,e,f,g,h,i,j,k,l,m,n,o
//思路5:但是当 n = 15时，完全倒序的数组需要排105次，显然不符合题目100次的要求，所以要在基础上进行修改
//思路6: 15个字母完全倒序 —— o,n,m,l,k,j,i,h,g,f,e,d,c,b,a 扣除5次排序，还要字典序最小，将第六个字母 j 移至第一位即可
//最终结果:j,o,n,m,l,k,i,h,g,f,e,d,c,b,a
String str = "jonmlkihgfedcba";
int str1[] = new int[str.length()];
for (int i = 0; i < str.length(); i++) {
str1[i] = str.charAt(i);
}
int count = 0;//记录交换次数
for (int i = 0; i < str1.length-1; i++) {
boolean swap = false;
for (int j = 0; j < str1.length-i-1; j++) {
if(str1[j] > str1[j+1]){
int temp = str1[j+1];
str1[j+1] = str1[j];
str1[j] = temp;
count++;
swap = true;
}
}
if(swap == false)
break;
}
System.out.println(count);
}
}
2.知识点
冒泡排序
（1）i、j都是从开头开始，每一轮循环最大的数会到最后
（2）j = str1.length-i-1
（3）boolean swap = false 如果循环一轮，没有任何数交换就提前结束
12.跑步锻炼
1.代码
package lanqiao11_20;
import java.time.DayOfWeek;
import java.time.LocalDate;
public class Running_12 {
public static void main(String[] args) {
LocalDate ldt = LocalDate.now();
LocalDate ldt1 = LocalDate.now();
ldt = ldt.of(2000,1,1);//开始时间
ldt1 = ldt1.of(2020,10,2);//结束时间 手动多一天，是为了在下边容易结束
int runkm = 0;
// System.out.println(ldt);
while (true){
if(ldt.equals(ldt1))
break;
if(ldt.getDayOfWeek() == DayOfWeek.MONDAY || ldt.getDayOfMonth() == 1) {
runkm += 2;
}else {
runkm += 1;
}
ldt = ldt.plusDays(1);
}
System.out.println(runkm);
}
}
13.蛇形填数
1.代码
package lanqiao11_20;
//找规律，把数字矩阵向左旋转45°，变成数字金字塔
//第二行第二列是金字塔的第三行，5是最中间的数
//第三行第三列是金字塔的第五行，13是最中间的数
//以此类推，第二十行第二十列是金字塔的第39行，求最中间的数（第20个数）
public class She_13 {
public static void main(String[] args) {
System.out.println(39*19+20);//第三十九行最中间的数 前38行(1+38)*38/2=39*19
}
}
//1 3 5 7 9 11 13 15 17 19 24
//a1 + (n-1)d
//39 38 (1+38)*38/2=39*19+20
14.递增序列
1.代码
package lanqiao11_20;
import java.util.Scanner;
//思路:1. 首先接收字符串数组，转成字符数组方便比较运算
// 2.遍历行、列
// 3.斜角45°一定要注意，题中说的意思只有（左下、右上、右下）
// 4.使用mn的值记录当前位置，方便对不同方向进行比较（注意：以后要一步一步输入，不要复制粘贴容易出错）
public class DiZeng_14 {
public static void main(String[] args) {
String a[] = new String[30];
char c[][] = new char[30][50];
Scanner scan = new Scanner(System.in);
for (int i = 0; i < a.length; i++) {
a[i] = scan.next();
}
//字符串数组 转成字符数组，方便比较
for (int i = 0; i < c.length; i++) {
for (int j = 0; j < c[i].length; j++) {
c[i][j] = a[i].charAt(j);
}
}
int count = 0;//记数
for (int i = 0; i < c.length; i++) {
for (int j = 0; j < c[i].length; j++) {
int m1 = i;
int m2 = i;
int m3 = i;
int n1 = j;
int n2 = j;
int n3 = j;
//判断两个数的排序，是0就不判断
//c[i][j]要判断的数 可以遍历完所有数
//c[][] i不变 j遍历全部 行
for (int k = j + 1; k < c[i].length; k++) {
if (c[i][j] < c[i][k]) {
count++;
System.out.println(c[i][j] + "" + c[i][k]);
}
}
//c[][] j不变 i遍历全部 列
for (int k = i + 1; k < c.length; k++) {
if (c[i][j] < c[k][j]) {
count++;
System.out.println(c[i][j] + "" + c[k][j]);
}
}
//c[][] 右上45角 c[i-1][j+1] i变小 j变大
while(true){
m1--;
n1++;
if(m1 < 0 || n1 > c[i].length-1)
break;
if(c[i][j] < c[m1][n1]) {
count++;
System.out.println(c[i][j] + "" + c[m1][n1]);
}
}
//c[][] 右下45角 c[i+1][j+1] i变大,j变大
while(true){
m2++;
n2++;
if(m2 > c.length-1 || n2 > c[i].length-1)
break;
if(c[i][j] < c[m2][n2]) {
count++;
System.out.println(c[i][j] + "" + c[m2][n2]);
}
}
//c[][] 左下45角 c[i+1][j+1] i变大,j变小
while(true){
m3++;
n3--;
if(m3 > c.length-1 || n3 < 0)
break;
if(c[i][j] < c[m3][n3]) {
count++;
System.out.println(c[i][j] + "" + c[m3][n3]);
}
}
}
}
System.out.println(count);
}
}
15.A+B（OJ示例题目）
比较简单，这里就不写了
16.杨辉三角形
1.代码
package lanqiao11_20;
import java.util.Scanner;
//通过率 20%
public class YangHui_16 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int m = n+2;
int a[][] = new int[n+1][m];
a[0][m-2] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= i; j++) {
a[i][m-j-2] = a[i-1][m-j-2] + a[i-1][m-j-1];
}
}
int count=0;
boolean skip = false;
for (int i = 0; i < a.length; i++) {
if(skip == true)
break;
for (int j = 0; j < a[i].length; j++) {
if(a[i][j] != 0) {
count++;
}
if(a[i][j] == n) {
skip = true;
break;
}
}
}
System.out.println(count);
}
}
2.知识点
上边这段代码是把杨辉三角看成右斜下形状计算了
但是由于题中给的用例：
N是long型，所以很多用例都通不过，上述代码只通过了20%，下边是新的解决思路。
package lanqiao11_20;
import java.util.Scanner;
//二分查找
public class YangHui2_16 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
long n = scan.nextLong();
long[] arr = new long[44725];
arr[0] = 1;
long k = 1L;
if (n == 1) {
System.out.println(1);
return;
}
for (int i = 1; i < 44725; i++) {
for (int j = i; j >= i - 16 && j >= 1; j--) {
arr[j] += arr[j - 1];
if (arr[j] == n) {
System.out.println(k + i - j + 1);
return;
}
}
k += (i + 1);
}
System.out.println(((1 + n) * n / 2) + 2);
}
}
解析
先看一下下面这个，是杨辉三角的前8行数据
1 0 0 0 0 0 0
1 1 0 0 0 0 0
1 2 1 0 0 0 0
1 3 3 1 0 0 0
1 4 6 4 1 0 0
1 5 10 10 5 1 0
1 6 15 20 15 6 1
1 7 21 35 21 7 1
找规律：
第一列：永远为1
第二列：从0开始的递增序列
第三列：1+2+3…的累加序列
分析：
第一列始终为1，不管；
第二列为n-1，也不管(你总不可能定义一个十亿行的数组对吧？)
那来看第三列，第三列的值为下图所示:
0
0+0
0+0+1
0+0+1+2
0+0+1+2+3
0+0+1+2+3+4
0+0+1+2+3+4+5
…
0+0+1+2+…+n
那么，如果说第三列的数值大于10亿了，并且在这之前都没有出现过所需要的值，那么我们是不是就可以判定这个值在第n+1行的第二位数？
那么就有了一个公式：（1+n）*n/2+2；而如果你直接用这个公式的话，可以得50分：
对于这题，50%好像不算太少了，上述代码只有20%
有了这50%的基础，那么我们就可以知道，剩下 的数值都是在第三列大于十亿之前可以求得的
那么就得判断一下前面到底有多少行数据需要获取：
而0+0+1+2+…+n>1e9,把前面两个0去除就是一个等差数列，且差值为1
可以求得n为44721；那么加上前面的两个0，就是第44723行数据
为了防止不确定因素，我们给它定为44725可以吧？
那问题又来了，定义一个44725行的二维数组， arr[44725][44725]？
这当然不可能，这样的话会内存超限，那接下来该怎么写呢？
我们可以用记忆化的方法去写着一个代码
每一行都有n个值，第一行1个，第二行2个，第n行n个，那最大行数44725就有44725个数值
1 0 0 0 0 0 0
1 1 0 0 0 0 0
1 2 1 0 0 0 0
1 3 3 1 0 0 0
1 4 6 4 1 0 0
1 5 10 10 5 1 0
1 6 15 20 15 6 1
1 7 21 35 21 7 1
第二行的第二列的1，是不是等于第一行的第二列的0+第一行第一列的1？
第三行第三列的1，等于第二行第三列的0+第二行第二列的1；
第三行第二列的2等于第二行第二列的1+第二行第一列的1；
这样子是不是就是要用到一个二维数组了？（第一种代码用的就是这种方法！）
正戏开始：
那我们换一个看法，第一行数据怎么变成第二行数据？
arr[1]=1;arr[2]=0;arr[3]…arr[n]=0;
第二列的值初始为0吧?第二行第二列的数是上面两个数的和对吧？
那就是0+arr[1]对吧，也就是arr【2】=0+arr【1】；
那arr【2】初始状态为0，是不是就可以写成：arr【2】=arr【2】+arr【1】？
那从第一行变成第二行后，怎么变成第三行？
arr【3】=arr【3】+arr【2】；
arr【2】=arr【2】+arr【1】；（这里需要好好看一下，实在不理解，可以手动计算下）
那第n行：arr【n】=arr【n】+arr【n-1】；arr【n-1】=arr【n-1】+arr【n-2】…；
//代码1：通过率80%，有两个用例超时
import java.util.Scanner;
public class 杨辉三角 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
long n = scan.nextLong();//输入值，查找
long[] arr =new long[44725];
arr[0]=1;
long k=1L;//k来定义位置
if (n == 1) {
System.out.println(1);
return;
}
for (int i = 1;i<44725; i++) {
for (int j = i; j>=1; j--) {
arr[j] += arr[j - 1];//换行后，进行运算，减少内存
if (arr[j] == n) {
System.out.println(k + i-j + 1);
return;//如果找到了就结束
}
}
k+=(i+1);//每一行有i个值
}
System.out.println(((1 + n) * n / 2) + 2);
}
}
分析一下超时的原因：
我们知道，杨辉三角是上行两数和，那么我们现在要看看它什么时候会出现超过十亿的值？
看上图我们可以知道 当运算到第三十四行的时候，就已经出现了大于10亿的值，位置是第16位，所以我们可以求得，每一次运算最多运算16个数值（杨辉三角对称原因，只求一半）
所以我们就可以求得，第n行最多要求的值为n-16------n这16个值
所以更改了代码
//代码2：通过了100%
import java.util.Scanner;
public class 杨辉三角 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
long n = scan.nextLong();
long[] arr =new long[44725];
arr[0]=1;
long k=1L;
if (n == 1) {
System.out.println(1);
return;
}
for (int i = 1;i<44725; i++) {
for (int j = i; j>=i-16&&j>=1; j--) {//这一块我也没看太懂
arr[j] += arr[j - 1];
if (arr[j] == n) {
System.out.println(k + i-j + 1);
return;
}
}
k+=(i+1);
}
System.out.println(((1 + n) * n / 2) + 2);
}
}
上边内容参考CSDN博主「笨笨的小怂宝」的文章，原文链接：https://blog.csdn.net/qq_55668645/article/details/123408119可以跳转参看
17.货物
1.代码
package lanqiao11_20;
import java.util.Scanner;
public class HuoWu_17 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
Long n = scan.nextLong();
// for (int i = 1; i <= n; i++) {
// for (int j = 1; j <= n; j++) {
// for (int k = 1; k <=n ; k++) {
// if(i*j*k==n)
// count++;
// }
// }
// }这种方法可能需要算好几天
int count1 = 0;//记录多少因子，然后再开辟空间
for (int i = 1; i <= Math.sqrt(n); i++) {
if (n % i == 0) {
count1++;
//求因子，为了不冗余计算，使用的是开根号，但是这里注意：方便计算的同时也要记录大的因子
if (n / i != i) {
count1++;
}
}
}
Long[] longs = new Long[count1];//因为这里，还没有学到arraylist，所以暂时使用开辟一维数组的方法
int x = 0;
for (Long i = 1l; i <= Math.sqrt(n); i++) {
if (n % i == 0) {
longs[x++] = i;
long m = n / i;
if (m != i) {
longs[x++] = m;
}
}
}
Long count = Long.valueOf(0);
for (int i = 0; i < longs.length; i++) {
for (int j = 0; j < longs.length; j++) {
for (int k = 0; k < longs.length; k++) {
if (longs[i] * longs[j] * longs[k] == n)
count++;
}
}
}
System.out.println(count);
}
}
18.九进制转十进制
1.代码
import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
public static void main(String[] args) {
System.out.println(2*1+2*9+0*81+2*729);
}
}
19.等差素数列
1.代码
package lanqiao11_20;
import java.util.Scanner;
public class DengCha_19 {
public static void main(String[] args) {
//判断素数
for (int i = 1; i < 10000; i++) {//范围
for (int j = 1; j < 1000; j++) {//公差
int k =0;
for (k = 0; k < 10; k++) {
if(!isSuShu(i+j*k))
break;
}
if(k == 10) {
System.out.println(i);//第一位数
System.out.println(j);
}
}
}
}
public static boolean isSuShu(int n){
for (int i = 2; i <= Math.sqrt(n); i++) {
if(n % i == 0)
return false;
}
return true;
}
}
20.七段码
这道题还暂时不会，没有学到图