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.排序

java蓝桥11-20题总结_第1张图片

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.跑步锻炼

java蓝桥11-20题总结_第2张图片

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.蛇形填数

java蓝桥11-20题总结_第3张图片

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.递增序列

java蓝桥11-20题总结_第4张图片java蓝桥11-20题总结_第5张图片

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示例题目)

java蓝桥11-20题总结_第6张图片
比较简单,这里就不写了

16.杨辉三角形

java蓝桥11-20题总结_第7张图片

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.货物

java蓝桥11-20题总结_第8张图片

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.九进制转十进制

java蓝桥11-20题总结_第9张图片

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.等差素数列

java蓝桥11-20题总结_第10张图片

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.七段码

java蓝桥11-20题总结_第11张图片
这道题还暂时不会,没有学到图

你可能感兴趣的:(java,开发语言)