备战蓝桥杯（ing）

        //字符串常用函数：length(),charAt(),substring(),indexOf(),lastIndexOf(),split(),replace(),trim(),toLowerCase(),toUpperCase()
        //字符串转字符数组：toCharArray()
        //字符串判断结尾：endsWith()
        //Java中常用集合类：ArrayList,LinkedList,HashMap,HashSet,TreeMap,TreeSet
        //集合特性：list有序，set无序，map键值对 key-value
        //map key-value键值对举例：HashMap<String,Integer> map = new HashMap<String,Integer>(); map.put("a",1); map.get("a");
/*
* 2019 Java C组第一题
* 小明对数位中含有2、0、1、9的数字很感兴趣，他要求你编程帮他计算一下从1到n(1<=n<=2019)中一共有多少个数的数位中包含有2、0、1、9。这些数的和是多少？
*思路分析：1.获取1-2019每个数字的千位、百位、十位、个位数字。将每一个数字和2、0、1、9进行比较，如果有一个相等，计数器加1
* 2.将数字转换成字符串，然后判断字符串中是否包含2、0、1、9
*/
public class demo1 {
    public static void main(String[] args) {

        int count=0;
        for(int k=1;k<2019;k++){
            String j=k+"";
            char[] chars=j.toCharArray();
            for(int l=0;l<chars.length;l++){
                if(chars[l]=='2'||chars[l]=='0'||chars[l]=='1'||chars[l]=='9'){
                    count+=k;
                    break;
                }
            }
        }
        System.out.println(count);
    }
}

/*
15 java c第二题
一些数字的立方末尾正好是该数本身。比如1、4、5、6、24、25；请你计算一下在10000以内的满足这个条件的正整数一共有多少个。
思路分析：已知循环次数。可以将数字和数字的立方转换成字符串，然后判断字符串的末尾是否等于该数字。str.endsWith(str2)
 */
public class demo2 {
    public static void main(String[] args) {
        for (int i = 0; i < 10000; i++) {
            String str = String.valueOf(i);
            String str2 = String.valueOf(i * i);
            if (str2.endsWith(str)) {
                System.out.println(i);
            }
        }
    }
}

/*
小明有一些矩形材料，他想从这些矩形材料中割出一些正方形。
现有一块矩形材料，两边长分别是2019和324。小明希望你帮他计算一下，他最多可以从这块矩形材料中割出多少个边长为整数的正方形？
思路分析：只知道循环终止条件不知道循环次数用while循环。长》宽，以宽为边长切正方形。宽》长，以长为边长切正方形。如果长宽相等，则不用切割
 */
public class demo3 {
    public static void main(String[] args) {
        int length = 2019;
        int width = 324;
        int count = 0;
        while (true) {
            if (length>width){
                length = length - width;
                count++;
            }
            else if (length<width&&length!=0){
                 width = width - length;
                 count++;
            }
            else if (length==width){
                count++;
                System.out.println(count);
                break;
            }
        }
    }
}
/*
5只猴子是好朋友，在海边的椰子树上睡着了。第一只猴子醒来，把香蕉均分5堆，多了一个，就吃了，拿走一堆。
第二只猴子醒来，重新把香蕉均分5堆，多了两个，就吃了，拿走一堆。后面的四只猴子都是这样做的。第五只猴子醒来，
香蕉均分成五堆正好不剩。问海边原来最少有多少个香蕉？
分析：不知道香蕉的数量，设为n个。用while循环，循环条件是true。
1.n%5==1，a=(n-1)/5*4
2.a%2=2 b=(a-1)/5*4
3.b%5=3 c=(b-3)/5*4
4.c%5=4 d=(c-1)/5*4
5.d%5=0 d>0
 */
public class demo4 {
    /**
     * 1.n%5==1，a=(n-1)/5*4
     * 2.a%2=2 b=(a-1)/5*4
     * 3.b%5=3 c=(b-3)/5*4
     * 4.c%5=4 d=(c-1)/5*4
     * 5.d%5=0 d>0
     */
    public static void main(String[] args) {
        int n=1;//代表香蕉的数量
        while(true){
            if(n%5==1){
                int a=(n-1)/5*4;
                if(a%5==2){
                    int b=(a-1)/5*4;
                    if(b%5==3){
                        int c=(b-3)/5*4;
                        if(c%5==4){
                            int d=(c-1)/5*4;
                            if(d%5==0&&d>0){
                                System.out.println(n);
                                break;
                            }
                        }
                    }
                }
            }
            n++;
        }
    }
}

    //字符串的循环和集合的使用
    //对集合的考察集中在集合的特性和功能。set唯一性，list有序性。以及集合元素的个数。
    /*
    2019 java c第三题
    一个字符串的非空子串是指字符串中长度至少为1的连续的一段字符组成的串。例如，字符串aaab有非空子串a, b, aa, ab, aaa, aab,  aaab，一共7个。
    注意在计算时，只算不同的串的个数。请问，字符串0100110001010001有多少个不同的非空子串？
    分析：set的唯一性，去除重复的子串
    aaab从第一个下标开始截取a,aa,aaa,aaab
    从第二个下标开始截取a,aa,aab
    下标0截取的范围[0，最大下标]
    下标1截取的范围[1，最大下标]
    截取的方式：substring(i,j) i为起始下标，j为结束下标
     */
import java.util.HashSet;

public class demo5 {
    public static void main(String[] args) {
        String string="0100110001010001";
        HashSet<Object> set = new HashSet<>();//去重
        for(int i = 0; i < string.length(); i++) {
            for (int j = i; j <= string.length(); j++) {
                String s = string.substring(i, j);
                set.add(s);
            }
        }
        System.out.println(set.size());
    }
}

    //循环求质数
    /**
     * 质数就是只能被1和它本身整除的数，1不是质数
     * 如何判断一个数字是不是质数：只能被1和它本身整除,找一下2到n-1之间有没有能被n整除的数
     * 整除：n%i==0
     */
    /*
    2019 java c第四题
    我们知道第一个质数是2，第二个质数是3，第三个质数是5，以此类推。请问，第2024个质数是多少？
    分析：我们可以先去求质数，再把求到的质数放入一个list里面，然后取出第2024个质数
     */
import java.util.ArrayList;

public class demo6 {
    public static void main(String[] args) {
        ArrayList<Long> list = new ArrayList<>();
        int a = 0; // 记录有没有除了1和他本身还可以整除的数字

        for (long i = 2; i < 20000; i++) {
            a = 0; // 在每次检查新数字之前重置a
            for (long j = 2; j < i; j++) {
                if (i % j == 0) {
                    a++;
                    break; // 只有找到一个能被整除的数就可以跳出循环，提高效率
                }
            }
            if (a == 0) {
                list.add(i);
            }
        }

        // 注意：确保列表中有至少2025个元素。如果没有，这将引发IndexOutOfBoundsException
        if (list.size() > 2023) {
            System.out.println(list.get(2023));
        } else {
            System.out.println("List does not contain 2024 elements.");
        }
    }
}
    /**
     * 排序与算法
     * 一、排序
     * 在一维数组中，对数组元素进行排序，可以使用冒泡排序、选择排序、插入排序、快速排序、等方法。
     * 1.冒泡排序
     * 原理：比较相邻的元素。如果第一个比第二个大，就交换他们两个。
        比较两个相邻的元素，将值大的元素交换到右边。2875943
     */
public class demo7 {
    public static void main(String[] args) {
        //外层for循环控制趟，内层控制次数
        int a[] ={2,8,7,5,9,4,3};
        for(int j=0;j<a.length-1;j++){
            for (int i=0;i<a.length-1;i++){
                if(a[i]>a[i+1]){
                    int temp = a[i];
                    a[i] = a[i+1];
                    a[i+1] = temp;
                }
            }
        }
        System.out.println("排序后的数组："+java.util.Arrays.toString(a));
    }
}
/*
2.选择排序
        * 原理：
        第一次：从未排序的数据元素里面，选出一个最小的（最大的），然后和第一位元素交换位置
        第二次：从未排序的数据元素里面，选出一个最小的（最大的），然后和第二位元素交换位置
        5871269
        min：1  1875269
        min：2  1275869
        ...
*/
public class demo8 {
    public static void main(String[] args) {
        int a []={2,9,5,0,1,3,6,8};
        int begin=0;
        int end=a.length-1;
        while (begin<end){
            int min=a[begin];//min，用来存储数组中元素的最小值
            int t=begin;//t，用来存储最小值的下标
            for(int i=begin;i<end;i++){
                if(min>a[i]){
                    min=a[i];
                    t=i;
                }
            }
            a[t]=a[begin];
            a[begin]=min;
            begin++;
        }
        for(int i=0;i<a.length;i++){
            System.out.print(a[i]+" ");
        }
    }
}
/*
3.插入排序
     原理：将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据
*/
public class demo9 {
    public static void main(String[] args) {
       int a []={2,9,5,0,1,3,6,8};
       for(int i=0;i<a.length;i++){
           int k=a[i];//哨兵，从数组第二位元素开始，将循环向后移动一位数组
           //将这个数插入到前面排好序的数组中
           int j=i-1;//排好序的数列的最后一位
           while (j>=0&&k<a[j]){//哨兵左边元素比他小右边比他大
               a[j+1]=a[j];//给哨兵的位置腾出空间
               j--;//用j记录哨兵最终插入的位置
           }
           a[j+1]=k;//插入哨兵
       }
       for (int i=0;i<a.length;i++){
           System.out.print(a[i]+" ");
       }

    }
}
/*

     *二、算法
     * 递归
     * 函数/方法  直接/间接 的调用本身。一般用来在数据原来的基础上加减乘除等操作
     * 案例：斐波那契数列
     * 1 1 2 3 5 8 13 21 34 55 89...第一个和第二个数字是1其他的数字等于前两个数字之和。
     * 计算第n位斐波那契数字
*/
public class demo10 {
    public static void main(String[] args) {
        System.out.println(Fn(10));
    }
    //递归：代码间接，但是涉及到的运算，会随着递归层数的增加成指数级增长。
    public static int Fn(int n){
        if(n==1||n==2){
            return 1;
        }
        return Fn(n-1)+Fn(n-2);
    }
}
/*
     * 2020 java c第三题：
     * 如下图所示，小明用从11开始的正整数“蛇形”填充无限大的矩阵
     * 1 2 6 7 15 16 28 29...
     * 3 5 8 14 17 27 30 ...
     * 4 9 13 18 26 31 ...
     * 10 12 19 25 32 ...
     * 11 20 24 33 ...
     * 21 23 34 ...
     * 22 35 ...
     * 容易看出矩阵第二行第二列中的数是5。请你计算矩阵中第20行第20列的数是多少？
     * 分析：第20行第20列处在45度这条线上，这条线上的数字是1 5 13 25 41...两数之差是：4 8 12 16...等差数列
     * 每一个数字都是前一个数字加上4，可以用递归或者循环
     * 第20行第20列的数字相当于这个数列的第20位数字。
     * 问题：递归和循环的关系？
     * 一道题可以用递归解答，也可以用循环解答。
     * 用循环代码量变多了，运算资源（时间复杂度）少了
     * 如果发现题目用递归运行时间超出限制，那么：
     ** 换循环
     **加字典
     * fn(5)=f(4)+f(3) f(4)=f(3)+f(2) 将f(3)和f(2)的值存起来 f(3)直接得出
*/
public class demo11 {
    public static void main(String[] args) {
        System.out.println(snack(20));
    }
    public static int snack(int n){
        if(n==1){
            return 1;
        }
        return snack((n-1)+4*(n-1));
    }
}
/*
     * 2.辗转相除法
     * 求两个数的最大公约数
     * *两个整数的最大公约数等于其中较小的数和两数相除余数的最大公约数(gcd)
     * gcd(a,b)=gcd(b,a%b) a>b 当b值为0时，a的值就是最大公约数
     * 案例：12和4的最大公约数=4和12%4=4和0的最大公约数=4
     * 案例：10和7的最大公约数 = 7和10%7=3的最大公约数 = 3和7%3=1的最大公约数 = 1和0
     * 题目：输入两个数字，求最大公约数？（循环递归都可以）
     */

import java.util.Scanner;

public class demo12 {
    //循环实现
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //a>b gcd(a,b)=gcd(b,a%b) a>b
        int a= scanner.nextInt();
        int b= scanner.nextInt();
        while (b!=0){
            int temp=a%b;
            a=b;
            b=temp;
        }
        System.out.println(a);

    }
}
import java.util.Scanner;
//递归实现
public class demo13 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int a= scanner.nextInt();
        int b= scanner.nextInt();
        System.out.println(gcd(a,b));
    }
    public static int gcd(int a, int b){
        if(b==0){
            return a;
        }
        return gcd(b,a%b);
    }
}