【刷题宝典NO.0】

已于 2023-11-24 16:20:18 修改
阅读量718 收藏 14
点赞数 13
分类专栏： 算法训练(不定期更) 文章标签： 算法 java 基础
于 2023-11-02 07:40:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TheMyth142857/article/details/134170568
版权

计算购物款

设某商店售货，按购买货物的钱数多少分别给予不同的优惠折扣:

(1)购货不足250元的，没有折扣;

(2)购货满250元，不足500元，折扣5%;

(3)购货满500元，不足1000元，折扣7. 5%;

(4)购货满1000元，不足2000元， 折扣10%;

(5)购货满2000元，折扣15%。

import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入购物款金额：");
        double amount = scanner.nextDouble();
        double discountRate = 0;
        double discountAmount = 0;
        if (amount < 250) {
            discountRate = 0;
        } else if (amount < 500) {
            discountRate = 0.05;
        } else if (amount < 1000) {
            discountRate = 0.075;
        } else if (amount < 2000) {
            discountRate = 0.1;
        } else {
            discountRate = 0.15;
        }
        discountAmount = amount * discountRate;
        double finalAmount = amount - discountAmount;
        System.out.println("购物款为：" + amount);
        System.out.println("折扣率为：" + discountRate);
        System.out.println("折扣金额为：" + discountAmount);
        System.out.println("实际支付金额为：" + finalAmount);
    }
}
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入购物款金额：");
        double amount = scanner.nextDouble();
        double discountRate = 0;
        double discountAmount = 0;
        int level = (int) (amount / 250);
        switch (level) {
            case 0:
                discountRate = 0;
                break;
            case 1:
                discountRate = 0.05;
                break;
            case 2:
            case 3:
                discountRate = 0.075;
                break;
            case 4:
            case 5:
            case 6:
            case 7:
                discountRate = 0.1;
                break;
            default:
                discountRate = 0.15;
        }
        discountAmount = amount * discountRate;
        double finalAmount = amount - discountAmount;
        System.out.println("购物款为：" + amount);
        System.out.println("折扣率为：" + discountRate);
        System.out.println("折扣金额为：" + discountAmount);
        System.out.println("实际支付金额为：" + finalAmount);
    }
}

显示系统当前时间

解题思路：

public class CurrentTime {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //自1970年1月1日零点到现在的毫秒时间（GMT）
        long currentTimeMillis = System.currentTimeMillis();
        //总秒数：
        long totalSeconds = currentTimeMillis/1000;
        //当前秒数：
        long seconds = totalSeconds%60;
        //总分钟数：
        long totalMinutes = totalSeconds/60;
        //当前分钟数：
        long minutes = totalMinutes%60;
        //总小时数：：
        long totalHours = totalMinutes/60;
        //当前小时数：
        long hours = totalHours%24;
        //东八区（UTC/GMT+08:00）是比世界协调时间（UTC）/格林尼治时间（GMT）快8小时的时区
        System.out.println("系统当前时间是："+(hours+8)+":"+minutes+":"+seconds);
    }
}

猜猜生日 

从1~31这个区间猜出你的生日：

根据五次询问生日是否在这个集合里面，输入0或者1，判断你的生日

import java.util.Scanner;
public class GuestBirthday{
        public static void main(String[] args){
                //第1位上为1的1~31间数字的集合
                String set1 = 
                " 1 3 5 7\n"+
                " 9 11 13 15\n"+
                "17 19 21 23\n"+
                "25 27 29 31";
                //第2位上为1的1~31间数字的集合
                String set2 = 
                " 2 3 6 7\n"+
                "10 11 14 15\n"+
                "18 19 22 23\n"+
                "26 27 20 31";
                //第3位上为1的1~31间数字的集合
                String set3 = 
                " 4 5 6 7\n"+
                "12 13 14 15\n"+
                "20 21 22 23\n"+
                "28 28 30 31";
                //第4位上为1的1~31间数字的集合
                String set4 = 
                " 8 9 10 11\n"+
                "12 13 14 15\n"+
                "24 25 26 27\n"+
                "28 29 30 31";
                //第5位上为1的1~31间数字的集合
                String set5 = 
                " 16 17 18 19\n"+
                "20 21 22 23\n"+
                "24 25 26 27\n"+
                "28 29 30 31";
                //定义一个变量用来存放天数
                int day = 0;
                Scanner sc = new Scanner(System.in);
                //第1次询问	
                System.out.println("你的生日(号数)在这个集合里面嘛？\n");
                System.out.println(set1);
                System.out.println("\n是，请输入1；否请输入0：");
                int answer = sc.nextInt();
                day += answer * 1;
                //第2次询问
                System.out.println("你的生日(号数)在这个集合里面嘛？\n");
                System.out.println(set2);
                System.out.println("\n是，请输入1；否请输入0：");
                answer = sc.nextInt();
                day += answer * (1<<1);
                //第3次询问
                System.out.println("你的生日(号数)在这个集合里面嘛？\n");
                System.out.println(set3);
                System.out.println("\n是，请输入1；否请输入0：");
                answer = sc.nextInt();
                day += answer * (1<<2);
                //第4次询问
                System.out.println("你的生日(号数)在这个集合里面嘛？\n");
                System.out.println(set4);
                System.out.println("\n是，请输入1；否请输入0：");
                answer = sc.nextInt();
                day += answer * (1<<3);
                //第5次询问
                System.out.println("你的生日(号数)在这个集合里面嘛？\n");
                System.out.println(set5);
                System.out.println("\n是，请输入1；否请输入0：");
                answer = sc.nextInt();
                day += answer * (1<<4);
                System.out.println("\n你的生日所在天是："+day+"号！");		
        }
}

素数的判定

题目内容：

给定一个数字，判定一个数字是否是素数

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        //方法1：让n去试除2--->n-1
//        Scanner sc = new Scanner(System.in);
//        int n = sc.nextInt();
//        int i = 2;
//        for (; i <= n - 1; i++) {    //让n去试除2--->n-1 比如：拿7试除2，3，4，5，6，因为7不能被2--->6内的数整除，说明7是素数
//            if (n % i == 0) {
//                break;
//            }
//        }
//        if (i == n) {   //如果i增长到n了，i == n > n - 1，也可以写成i > n-1 , 说明n只能被它自己整除，即素数
//            System.out.println(n + "是素数");
//        }
        //方法2：让n去试除2--->n/2
//        Scanner sc = new Scanner(System.in);
//        int n = sc.nextInt();
//        int i = 2;
//        for (; i <= n / 2; i++) {   //让n去试除2--->n/2，比如：16 ：1*16 2*8 4*4 总存在一个数<=2/n
//            if (n % i == 0) {
//                break;
//            }
//        }
//        if (i > n / 2) {   //如果i == (2+n)/2 > n/2 了，也可以写成i > n / 2，说明n只能被它自己整除，即素数
//            System.out.println(n + "是素数");
//        }
        //方法3：让n去试除2--->根号n
//        Scanner sc = new Scanner(System.in);
//        int n = sc.nextInt();
//        int i = 2;
//        for (; i <= Math.sqrt(n); i++) {   //让n去试除2--->根号n，比如： 根号n * 根号n = n 总存在一个数<=根号n
//            if (n % i == 0) {
//                break;
//            }
//        }
//        if (i > Math.sqrt(n)) {   //如果i > 根号n，说明n只能被它自己整除，即素数
//            System.out.println(n + "是素数");
//        }
//    }
        //方法4：同方法3一样，多引入一个开关 在这有点多此一举
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int flag = 1;   //引入一个开关，1是素数 0不是素数
        int i = 2;
        for (; i <= Math.sqrt(n); i++) {   //让n去试除2--->根号n，比如： 根号n * 根号n = n 总存在一个数<=根号n
            if (n % i == 0) {
                flag = 0;   //如果能被整除，说明不是素数，结束本次循环
                break;
            }
        }
        if (1 == flag) {    //说明是素数
            System.out.println(n + "是素数");
        }
    }
}

 52b65791589241b8ae1752571ba85823.png

打印素数

题目内容：
打印 1 - 100 之间所有的素数，并统计素数的个数

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        //方法1：引入开关
//        Scanner sc = new Scanner(System.in);
//        int n = sc.nextInt();
//        int count = 0;
//        int j = 2;
//        for (; j <= n; j++) {
//            int flag = 1;//引入一个开关，1是素数 0不是素数
//            int i = 2;
//            for (; i <= Math.sqrt(j); i++) {//让j去试除2--->根号j，比如： 根号n * 根号n = n 总存在一个数<=根号n
//                if (j % i == 0) {//如果能被整除，说明不是素数，结束本次循环
//                    flag = 0;
//                    break;
//                }
//            }
//            if (1 == flag) {//是素数就记录个数并打印
//                count++;
//                System.out.print(j + " ");
//            }
//        }
//        System.out.print("count = " + count);
        //方法2：改进版，将判断素数的方法封装成函数提出去
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int count = 0;
        int i = 1;
        for (; i <= n; i++) {
            if (isPrimer(i) == 1) {
                count++;
                System.out.print(i + " ");
            }
        }
        System.out.print("count = " + count);
    }

    //判断是否为素数
    public static int isPrimer(int n) {
        int i = 2;
        for (; i <= Math.sqrt(n); i++) {   //让n去试除2--->根号n，比如： 根号n * 根号n = n 总存在一个数<=根号n
            if (n % i == 0) {
                return 0;
            }
        }
        return 1;
    }
}

756478f236494571b2916994cd1558db.png

打印水仙花数 

题目内容：

求出0～100000之间的所有“水仙花数”并输出。

“水仙花数”是指一个n位数，其各位数字的n次方之和确好等于该数本身，如:153＝1^3＋5^3＋3^3，则153是一个“水仙花数”。

public class OnlineTest {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        int i = 0;
        for (i = 0; i <= 100000; i++) {
            // 判断i是否为自幂数
            // 1. 计算i的位数
            int n = 1; // 一个数至少是一位数
            int tmp = i;
            while ((tmp /= 10) != 0) {
                n++;
            }
            // 2. 得到的i的每一位，求每一位的n次方和
            tmp = i;//刚刚是把tmp做了处理的，现在要重新赋值一次
            int sum = 0;
            while (tmp > 0) {
                sum += (int) Math.pow(tmp % 10, n);
                tmp /= 10;
            }
            if (sum == i) {
                System.out.print(i + " ");
            }
        }
    }
}

28cc0c5544a44ea1ac31713702e29344.png

百钱买百坤

public class OnlineTest {
    public static void main(String[] args) {
        //公鸡，母鸡，小鸡三个不是必须都有
        int cock, hen, chick;
        for (cock = 1; cock <= 20; cock++) {
            for (hen = 1; hen <= 33; hen++) {
                for (chick = 3; chick <= 99; chick += 3) {
                    if (cock * 5 + hen * 3 + chick / 3 == 100) {
                        if (cock + hen + chick == 100) {
                            System.out.println("公鸡：" + cock + "母鸡：" + hen + "小鸡：" + chick);
                        }
                    }
                }
            }
        }
    }
}

public class OnlineTest {
    public static void main(String[] args) {
        /*
        百钱买百鸡：
        公鸡5文钱一只，母鸡3文钱一只，小鸡3只一文钱，
        用100文钱买一百只鸡,其中公鸡，母鸡，小鸡都必须要有，问公鸡，母鸡，小鸡要买多少只刚好凑足100文钱。
        数学：
        设未知数：
        公鸡：x只
        母鸡：y只
        小鸡：z只
        x+y+z=100只
        5x+3y+z/3=100钱
        麻烦方式：//下面那个代码不需要判断z%3==0，是因为每次z+=3，z的增长已经是三的倍数了。
        for(int x=1;x<=100;x++){
                for(int y=1;y<=100;y++){
                        for(int z=1;z<=100;z++){//可以修改为(int z=3;z<=100;z+=3),下面就不需要再z%3==0了。
                                if((x+y+z==100)&&(5*x+3*y+z/3==100)&&(z%3==0)){
                                        System.out.println(x+"\t"+y+"\t"+z);
                                }
                        }
                }
        }
        */
        //优化：
        for (int x = 1; x <= 19; x++) {//100-1-3=96,96/5=19
            for (int y = 1; y <= 31; y++) {//100-5-1=94,94/3=31
                int z = 100 - x - y;
                if ((5 * x + 3 * y + z / 3 == 100) && (z % 3 == 0)) {
                    System.out.println(x + "\t" + y + "\t" + z);
                }
            }
        }
    }
}

 629f258ee2974e21bed5a3597487f2f7.png

找最大值

题目内容：

输入n个整数，输出最大值

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入整数的个数 n: ");
        int n = scanner.nextInt();

        int[] numbers = new int[n];

        // 依次输入 n 个整数
        for (int i = 0; i < n; i++) {
            System.out.print("请输入第 " + (i + 1) + " 个整数: ");
            numbers[i] = scanner.nextInt();
        }

        int max = numbers[0];

        // 寻找最大值
        for (int i = 1; i < n; i++) {
            if (numbers[i] > max) {
                max = numbers[i];
            }
        }

        System.out.println("输入的 " + n + " 个整数中最大的数是: " + max);
    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入整数的个数 n: ");
        int n = scanner.nextInt();

        int[] numbers = new int[n];

        // 依次输入 n 个整数
        for (int i = 0; i < n; i++) {
            System.out.print("请输入第 " + (i + 1) + " 个整数: ");
            numbers[i] = scanner.nextInt();
        }

        int max = Integer.MIN_VALUE;
        // 寻找最大值
        for (int i = 0; i < n; i++) {
            max = Math.max(max, numbers[i]);
        }

        System.out.println("输入的 " + n + " 个整数中最大的数是: " + max);
    }
}

输出闰年

题目内容：
输出 1000 - 2000 之间所有的闰年 

public class OnlineTest {
    public static boolean isLeapYear(int year) {
//        if ((year % 400 == 0) || (year % 4 == 0 && year % 100 != 0)) {
//            return true;
//        }else{
//            return false;
//        }
        return ((year % 400 == 0) || (year % 4 == 0 && year % 100 != 0));
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        for (int year = 1000; year <= 2000; year++) {
            boolean flag = isLeapYear(year);
            if (flag == true) {
                System.out.println(year + "是闰年！");
            }
        }
    }
}

9301226d54fd49399f8e188713aad134.png

逆序打印一个整数的每一位

题目内容：
逆序打印一个整数的每一位，如：123的每一位是3，2，1

本题主要考虑，如何获取一个数字的每一位：
123 % 10 = 3
123/10=12 12%10=2
12/10=1 1%10= 1

import java.util.Scanner;
public class OnlineTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        while (n != 0) {
            System.out.print(n % 10 + " ");
            n /= 10;
        }
    }
}

d0fe914df6834ca58d26513ab4d3f5ca.png

输出乘法口诀表 

题目内容：
输出n*n的乘法口诀表，n由用户输入。

import java.util.Scanner;
public class OnlineTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(i + "*" + j + "=" + i * j + "\t");
            }
            System.out.println();
        }
        for (int i = n; i >= 1; i--) {
            for (int j = 1; j <= i; j++) {
                System.out.print(i + "*" + j + "=" + i * j + "\t");
            }
            System.out.println();
        }
    }
}

 846dc06a49ed47b989e66d6cdf8da3b5.png

数字9出现的次数 

题目内容：
编写程序数一下 1到 100 的所有整数中出现多少个数字9

public class OnlineTest {
    public static void main(String[] args) {
        int count = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 10 == 9) {//判断个位的9
                count++;
            }
            if (i / 10 == 9) {
                count++;//判断十位的9
            }
            //多少个数字出现过9，此时99算1个数字，即一共19个
            /*if (i % 10 == 9) {//判断个位的9
                count++;
            }
            else if(i / 10 == 9) {
                count++;//判断十位的9
            }*/
        }
        System.out.println(count);
    }
}

a4263a2f356d42ccb0e63a0b9ae20954.png

二进制1的个数 

题目内容：
求一个整数，在内存当中存储时，二进制1的个数。

import java.util.Scanner;
public class OnlineTest {
    //方法1：
    /*public static int numberOf1(int n) {
        int count = 0;
        for (int i = 0; i < 32; i++) { //n可以在2进制中表示32位，每次让n无符号向右移动一位，每一位和1相与
            if (((n >>> i) & 1) == 1) {
                count++;
            }
        }
        return count;
    }*/
    //方法2：
    /*public static int numberOf1(int n) {
        int count = 0;
        *//*for (int i = 0; i < 32; i++) {
            if ((n & 1) == 1) {
                count++;
            }
            n >>>= 1;
        }*//*
        while (n != 0) {
            if ((n & 1) != 0) {
                count++;
            }
            n >>>= 1;
        }
        return count;
    }*/
    //方法3：n & (n - 1) 每次消去一个1，记录消去1的次数，直到1全部被消去变为0为止
    public static int numberOf1(int n) {
        int count = 0;
        while (n != 0) {
            n = n & (n - 1);    //n &= n - 1;
            count++;
        }
        return count;
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int ret = numberOf1(n);
        System.out.println(ret);
    }
}

8e2417259b49497ea3a7bfb90c54a33c.png

717701d90235413194b44688c895eb5c.png

输出一个整数的偶数位和奇数位的二进制序列  

import java.util.Scanner;
public class OnlineTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        //偶数位 下标从1开始（第二个数），每次让n右移2位让偶数位 和 1做 & 运算，如果结果是1说明当前偶数位是1，同理结果是0。。。
        for (int i = 31; i >= 1 ; i-=2) {
            System.out.print(((n >> i) & 1)+" ");
        }
        System.out.println();
        //奇数位 下标从0开始（第一个数），每次让n右移2位让奇数位 和 1做 & 运算，如果结果是1说明当前奇数位是1，同理结果是0。。。
        for (int i = 30; i >= 0 ; i-=2) {
            System.out.print(((n >> i) & 1)+" ");
        }
    }
}

bffc70fa3f804d30b27db333c7ec0bd2.png

a6123d50e1ba40e98942e616cb5ff778.png

 0a4b37185d3248e6b4c52eccae4d58f8.png 

求两个整数的最大公约数 

题目内容：
给定两个数，求这两个数的最大公约数

例如：

输入：20 40

输出：20

import java.util.Scanner;
public class OnlineTest {
    public static void main(String[] args) {
        //方法1：找出m和n之间的最小值min，用m和n同时对min整除，如果同时被整除，那么这个min就是最大公约数，如果不能整除，那么就min--
        /*Scanner in = new Scanner(System.in);
        int m = in.nextInt();
        int n = in.nextInt();
        int min = m > n ? n : m;
        while (true) {
            if (m % min == 0 && n % min == 0) {
                System.out.println("最大公约数：" + min);
                break;
            }
            min--;
        }*/
        //方法2：辗转相除法 m % n = r ,如果r != 0，m = n，n = r，当r = 0时，n为最大公约数
        // 例如：m:24 n:18 第一次：m % n = 24 % 18 = 6 第二次：18 % 6 = 0，6为最大公约数
        Scanner in = new Scanner(System.in);
        int m = in.nextInt();
        int n = in.nextInt();
        /*int r = m % n;
        while (r != 0) {
            m = n;
            n = r;
            r = m % n;
        }*/
        int r = 0;
        while ((r = m % n) != 0) {
            m = n;
            n = r;
        }
        System.out.println("最大公约数：" + n);
    }
}

a5d4f89bda664e68975f44837ba12031.png

求两个整数的最小公倍数 

题目内容：
给定两个数，求这两个数的最小公倍数

例如：

输入：12 15

输出：60

import java.util.Scanner;
public class OnlineTest {
    public static void main(String[] args) {
        //找出m和n之间的最大值max，用max对m和n整除，如果同时整除了m和n，那么这个max就是最小公倍数，如果不能整除，那么就max++
        Scanner in = new Scanner(System.in);
        int m = in.nextInt();
        int n = in.nextInt();
        int max = m > n ? m : n;//或者int max = Math.max(m, n);
        while (true) {
            if (max % m == 0 && max % n == 0) {
                System.out.println("最小公倍数：" + max);
                break;
            }
            max++;
        }
    }
}

004f50e0134b429cb02de13e7528904f.png

小乐乐与欧几里得

https://www.nowcoder.com/share/jump/4389976241698855052246

描述

小乐乐最近在课上学习了如何求两个正整数的最大公约数与最小公倍数，但是他竟然不会求两个正整数的最大公约数与最小公倍数之和，请你帮助他解决这个问题。

输入描述：

每组输入包含两个正整数n和m。(1 ≤ n ≤ 109，1 ≤ m ≤ 109)

输出描述：

对于每组输入，输出一个正整数，为n和m的最大公约数与最小公倍数之和。

示例1

输入：

10 20

输出：

30

示例2

输入：

15 20

输出：

65

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long m = scanner.nextLong();
        long n = scanner.nextLong();
        long m2 = m;
        long n2 = n;
        long r = 0;
        //最大公约数
        while ((r = m2 % n2) != 0) {
            m2 = n2;
            n2 = r;
        }
        long max = n2;
        //最小公倍数：m * n / 最大公约数
        long min = m * n / n2;
        System.out.println(max + min);
    }
}

小乐乐与进制转换

https://www.nowcoder.com/share/jump/4389976241698856221648

描述

小乐乐在课上学习了二进制八进制与十六进制后，对进制转换产生了浓厚的兴趣。因为他的幸运数字是6，所以他想知道一个数表示为六进制后的结果。请你帮助他解决这个问题。

输入描述：

输入一个正整数n  (1 ≤ n ≤ 109)

输出描述：

输出一行，为正整数n表示为六进制的结果

示例1

输入：

6

输出：

10

示例2

输入：

120

输出：

320

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int arr[] = new int[20];
        int i = 0;
        while (n > 0) {
            arr[i] = n % 6;
            n /= 6;
            i++;
        }
        for (--i; i >= 0; i--) {
            System.out.print(arr[i]);
        }
    }
}

计算分数的值

题目内容：
计算1/1-1/2+1/3-1/4+1/5 …… + 1/99 - 1/100 的值 。

思路：
1. 从上述表达式可以分析出
   该表达式主要由100项，奇数项为正，偶数项为负
2. 设置一个循环从1~100，给出表达式中的每一项：1.0/i, 注意此处不能使用1，否则结果全部为0
  然后使用flag标记控制奇偶项，奇数项为正，偶数项为负
  然后将所有的项相加即可

public class OnlineTest {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        double sum = 0.0;
        int flag = 1;
        for (int i = 1; i <= 100; i++) {
            sum += 1.0 * flag / i;
            flag = -flag;
        }
        System.out.println(sum);
    }
}

 06cd35f6bc244e1f85bef961041c995b.png

计算求和

题目内容：

求Sn=a+aa+aaa+aaaa+aaaaa的前5项之和，其中a是一个数字，

例如：2+22+222+2222+22222

import java.util.Scanner;

public class OnlineTest {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        int n = scanner.nextInt();
        int i = 0;
        int Sn = 0;
        int k = 0;
        for (i = 0; i < n; i++) {
            k = k * 10 + a;
            Sn += k;
        }
        System.out.println(Sn);
    }
}

0f16cfe1e97e447b8c0f2b6ace57fc6a.png

数列求和 

数列求和

09508f6b56e1485499d686ae7f4f3456.png

前n（n<=20）项之和。（不使用if…else等选择分支语句）
思路：
1.推导公式：

0b8b2efd1a534dbdbca5ef43d215e2cc.png

2.每次循环累加的时候符号要变换，引入一个开关，控制正负号
3.在循环里面的时候a的值每次还要减a，不然a会一直累加，a的值是相对于上个式子的b基础上+1的

import java.util.Scanner;
public class Main {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        //b/a == b=a+b/a=b+1
        double b = 2; //起始分子
        double a = 1; //起始分母
        double sum = 0.0;
        int flag = 1;
        for (int i = 0; i < n; i++) {
            sum += 1.0 * flag * b / a; //累加
            b += a;  //分子
            a = b + 1 - a;  //分母 注意这儿每次循环要-a，因为每次循环分母a的值会累加，a的值是相对于上个式子的b基础上+1
            flag = -flag;
        }
        System.out.println(sum);
    }
}

 0310e6243f554d9b951a8699f073a588.png

打印各种图案

打印长方形

7eea04fb926e4dc7bc9f4438f270de5c.png

public class OnlineTest {
    public static void main(String[] args) {
        for (int j = 1; j <= 4; j++) {//j:控制行数
            //*********
            for (int i = 1; i <= 9; i++) {//i:控制*的个数
                System.out.print("*");
            }
            //换行：
            System.out.println();
        }
    }
}

9d9f97b6e7a34b92bd33403d2d31ae4a.png

打印距离前面有一定空隙的长方形

0979c3f91034447daa5566b06571d037.png

public class OnlineTest {
    public static void main(String[] args) {
        for (int j = 1; j <= 4; j++) {//j:控制行数
            //加入空格：
            for (int i = 1; i <= 5; i++) {//i:控制空格的个数
                System.out.print(" ");
            }
            //*********
            for (int i = 1; i <= 9; i++) {//i:控制*的个数
                System.out.print("*");
            }
            //换行：
            System.out.println();
        }
    }
}

f272f659fb394adf86e7903432717ecd.png

打印空心正方形

https://www.nowcoder.com/share/jump/1698854024034

描述

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的“空心”正方形图案。

输入描述：

多组输入，一个整数（3~20），表示输出的行数，也表示组成正方形边的“*”的数量。

输出描述：

针对每行输入，输出用“*”组成的“空心”正方形，每个“*”后面有一个空格。

示例1

输入：

4

输出：

* * * * 
*     * 
*     * 
* * * *

示例2

输入：

5

输出：

* * * * * 
*       * 
*       * 
*       * 
* * * * * 
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int n = scanner.nextInt();
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if ((i == 0) || (i == n - 1) || (j == 0) || (j == n - 1))
                        System.out.print("* ");
                    else
                        System.out.print("  ");
                }
                System.out.println();
            }
        }
        scanner.close();
    }
}

打印 X 图形 

https://www.nowcoder.com/practice/83d6afe3018e44539c51265165806ee4

描述

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的X形图案。

输入描述：

多组输入，一个整数（2~20），表示输出的行数，也表示组成“X”的反斜线和正斜线的长度。

输出描述：

针对每行输入，输出用“*”组成的X形图案。

示例1

输入：

5

复制输出：

*     *
  * *
   * 
  * *
*    *

复制

示例2

输入：

6

复制输出：

*        *
  *    *
   * * 
   * * 
  *   *
*       *

import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int n  = in.nextInt();
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if ((i == j) || (i + j == n - 1)) {
                        System.out.print("*");
                    } else {
                        System.out.print(" ");
                    }
                }
                System.out.println();
            }
        }
    }
}

打印平行四边形

23ebc3d0e56548daa62babc6e7fc4cf4.png

public class OnlineTest {
    public static void main(String[] args) {
        for (int j = 1; j <= 4; j++) {//j:控制行数
            //加入空格：
            for (int i = 1; i <= (9 - j); i++) {//i:控制空格的个数
                System.out.print(" ");
            }
            //*********
            for (int i = 1; i <= 9; i++) {//i:控制*的个数
                System.out.print("*");
            }
            //换行：
            System.out.println();
        }
    }
}

94cb15a7ca944d99a3808aebad69fa47.png

打印三角形

592a97074f994b3bba39ecebab98d605.png

public class OnlineTest {
    public static void main(String[] args) {
        for (int j = 1; j <= 4; j++) {//j:控制行数
            //加入空格：
            for (int i = 1; i <= (9 - j); i++) {//i:控制空格的个数
                System.out.print(" ");
            }
            //*********
            for (int i = 1; i <= (2 * j - 1); i++) {//i:控制*的个数
                System.out.print("*");
            }
            //换行：
            System.out.println();
        }
    }
}

8ada18b9f782475c9e2dba361b1e6de1.png

打印菱形

52a15e17d15b4048b0fc7e57935fb465.png

public class OnlineTest {
    public static void main(String[] args) {
        //上面三角形：
        for (int j = 1; j <= 4; j++) {//j:控制行数
            //加入空格：
            for (int i = 1; i <= (9 - j); i++) {//i:控制空格的个数
                System.out.print(" ");
            }
            //*********
            for (int i = 1; i <= (2 * j - 1); i++) {//i:控制*的个数
                System.out.print("*");
            }
            //换行：
            System.out.println();
        }

        //下面三角形：
        for (int j = 1; j <= 3; j++) {//j:控制行数
            //加入空格：
            for (int i = 1; i <= (j + 5); i++) {//i:控制空格的个数
                System.out.print(" ");
            }
            //*********
            for (int i = 1; i <= (7 - 2 * j); i++) {//i:控制*的个数
                System.out.print("*");
            }
            //换行：
            System.out.println();
        }
    }
}

d7ca106188364222a18c9ee4cb419aa5.png

public class OnlineTest {
    public static void main(String[] args) {
        //先打印出一个正方形，然后某些位置上打印* 某些位置上打印空格：
        int size = 17;
        int startNum = size / 2 + 1;//起始列号
        int endNum = size / 2 + 1;//结束列号
        //引入一个布尔类型的变量---》理解为“开关”
        boolean flag = true;
        for (int j = 1; j <= size; j++) {
            //*****
            for (int i = 1; i <= size; i++) {
                if (i >= startNum && i <= endNum) {
                    System.out.print("*");
                } else {
                    System.out.print(" ");
                }
            }
            //换行
            System.out.println();
            if (endNum == size) {
                flag = false;
            }

            if (flag) {//flag是true相当于在菱形的上半侧   flag是false相当于在菱形的下半侧
                startNum--;
                endNum++;
            } else {
                startNum++;
                endNum--;
            }
        }
    }
}

 2a0701a23c70490fb05c3d158cd7e511.png

打印空心菱形 

4f18d12a936d4142a512d85051cb1990.png

public class OnlineTest {
    public static void main(String[] args) {
        //先打印出一个正方形，然后某些位置上打印* 某些位置上打印空格：
        int size = 17;
        int startNum = size / 2 + 1;//起始列号
        int endNum = size / 2 + 1;//结束列号
        //引入一个布尔类型的变量---》理解为“开关”
        boolean flag = true;
        for (int j = 1; j <= size; j++) {
            //*****
            for (int i = 1; i <= size; i++) {
                if (i == startNum || i == endNum) {
                    System.out.print("*");
                } else {
                    System.out.print(" ");
                }
            }
            //换行
            System.out.println();
            if (endNum == size) {
                flag = false;
            }

            if (flag) {//flag是true相当于在菱形的上半侧   flag是false相当于在菱形的下半侧
                startNum--;
                endNum++;
            } else {
                startNum++;
                endNum--;
            }
        }
    }
}

 6ad94c2db9b24410ac4fd49ce4335b9a.png

小乐乐走台阶

https://www.nowcoder.com/share/jump/4389976241698854945904

描述

小乐乐上课需要走n阶台阶，因为他腿比较长，所以每次可以选择走一阶或者走两阶，那么他一共有多少种走法？

输入描述：

输入包含一个整数n (1 ≤ n ≤ 30)

输出描述：

输出一个整数，即小乐乐可以走的方法数。

示例1

输入：

2

输出：

2

示例2

输入：

10

输出：

89

import java.util.Scanner;

public class Main {
    public static int walk(int n) {
        if (n <= 2) {
            return n;
        } else {
            return walk(n - 1) + walk(n - 2);
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int ret = walk(n);
        System.out.println(ret);
        scanner.close();
    }
}

斐波那契数列 

题目内容：
求斐波那契数列的第n项。(迭代实现)


斐波那契数列定义为：1 1 2 3 5 8 13 21 我们可以看到，从第3项开始，都等于前一项+前一项的前一项的和。
3=1+2
5+2+3
13 = 5+8
我们可以先定义f1保存第一项的值，f2保存第2项的值，f3保存第3项的值。
每次算法一个f3，就同步更新f1和f2的值。

import java.util.Scanner;
public class OnlineTest {//1.递归实现斐波那契数列
    public static int fib1(int n) {
        if (n <= 2) {
            return 1;
        } else {
            return fib1(n - 1) + fib1(n - 2);
        }
    }
    //2.       fib: 1   1   2   3   5
    //              a + b = c
    //                  a + b = c
    //          n: 1   2   3   4   5
    //                     n = 3，即n > 2时，有 c = a + b ; a = b ; b = c
    public static int fib2(int n) {
        int a = 1;
        int b = 1;
        int c = 0;
        while (n > 2) {//从第三项开始
            c = a + b;
            a = b;
            b = c;
            n--;
        }
        return c;
    }
    public static int fib3(int n) {
        if (n == 1 || n == 2) {
            return 1;
        }
        int f1 = 1;
        int f2 = 1;
        int f3 = 0;
        for (int i = 3; i <= n; i++) {
            f3 = f1 + f2;
            f1 = f2;
            f2 = f3;
        }
        return f3;
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int ret1 = fib1(n);
        int ret2 = fib2(n);
        int ret3 = fib3(n);
        System.out.println("递归实现：" + ret1);
        System.out.println("--------------");
        System.out.println("非递归实现：" + ret2);
        System.out.println("非递归实现：" + ret3);
    }
}

 1e0ae15494934b65870a02b1fb9615f0.png

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        System.out.println(fib(n));
    }

    public static int fib(int n) {
        if (n <= 2) {
            return n;
        }
        int[] dp = new int[n + 1];
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
}

递归实现n的k次方 

public class OnlineTest {
    public static void main(String[] args) {
        int n = 2;
        int k = -1;
        System.out.println(power(n, k));
    }
    public static double power(int n, int k) {
        if (k == 0) {
            return 1;
        } else if (k > 0 ){
            return n * power(n, k - 1);
        } else {//k < 0
            return 1.0 / power(n, -k);
        }
    }
}

3ecf4a90f5854a188d84bc4d7310263f.png

递归求 N 的阶乘

题目内容：
递归求 N 的阶乘
递归代码重要的是推导递推公式：假设N的阶乘用F(n)表示，那么F(n) = n * F(n-1);

import java.util.Scanner;
public class OnlineTest {
    public static int fac(int n) {
        if(n < 2) {
            return 1;
        }
        return n * fac(n-1);
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        System.out.println(fac(n));
    }
}

fd01ab29ab3a4b8aaf78602d6ef67006.png

递归求和 

题目内容：
递归求 1 + 2 + 3 + ... + 10

假设用F(n) 代表1-n的和，那么F(n) = n + F(n-1)的和
F(n-1)就是1到n-1的和

import java.util.Scanner;
public class OnlineTest {
    public static int sum(int n) {
        if(n == 1) {
            return 1;
        }
        return n + sum(n-1);
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        System.out.println(sum(n));
    }
}

8406fa4b598c496eb5b440dd364b08d3.png

递归打印数字的每一位 

题目内容：
按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4) （递归）
假设用F(n) 代表 要顺序打印n的每一位，如果n是一个1位数，直接输出，如果n是2位数以上。
如：
123 相当于先打印12的每一位，再打印3
12 相当于先打印1的每一位，再打印2
1 只有一位数，直接打印。
依次回退打印完，每一位即可。

public class OnlineTest {
    //写法1：
    public static void print(int num) {
        if (num > 9) {
            print(num / 10);
        }
        System.out.println(num % 10);
    }
    //写法2：
    public static void fun(int n) {
        if (n <= 9) {
            System.out.println(n);
            return; //出口，不然会栈溢出错误（必须由程序员解决）
        }
        fun(n / 10);
        System.out.println(n % 10);
    }
    public static void main(String[] args) {
        fun(1234);
        System.out.println("-----");
        print(1234);
    }
}

 f71e157c2da24de09cf42e67d757479f.png

返回的数字之和 

题目内容：
写一个递归方法，输入一个非负整数，返回组成它的数字之和

要计算123的每一位，主要在于如何得到每一位。在前面的习题中我们知道，除10 ， 模10.可以做到。
如下图，在执行n=123的时候，先执行add(123/10)也就是add(12)这个函数，等最后回来之后，才会把n=123时候的n%10算完。

84daa550e52f4fc0b9c0d61a3a2a2399.png

public class OnlineTest {
    public static int digitSum(int n) {
        if (n <= 9) {
            return n;
        }
        return n % 10 + digitSum(n / 10);
    }
    public static void main(String[] args) {
        System.out.println(digitSum(1729));
    }
}

0bc9befe1bf34666973d8fcca7902e75.png

TheMythWS
关注
  • 13
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 13
    评论
专栏目录
《数据结构与算法 LeetCode刷题宝典》.docx
01-18
本文档使用python、#C两种语言向我们展示了常见一些算法。
1000面试题，BAT机器学习面试刷题宝典.rar
05-26
1000面试题，BAT机器学习面试刷题宝典
【刷题宝典NO.2】
TheMyth142857的博客
10-30 653
如果 Bob 拿走前 3 颗，那么剩下的是 [4,5]，Alice 拿走后 5 颗赢得 10 分。如果 Bob 拿走后 5 颗，那么剩下的是 [3,4]，Alice 拿走后 4 颗赢得 9 分。这表明，取前 5 颗石子对 Alice 来说是一个胜利的举动，所以返回 true。注意，要求返回第三大的数，是指在所有不同数字中排第三大的数。Alice 先开始，只能拿前 5 颗或后 5 颗石子。假设他取了前 5 颗，这一行就变成了 [3,4,5]。如果喝掉了水瓶中的水，那么水瓶就会变成空的。
【刷题宝典NO.1】
TheMyth142857的博客
10-29 734
你和你的朋友，两个人一起玩桌子上有一堆石头。你们轮流进行自己的回合，。每一回合，轮到的人拿掉 1 - 3 块石头。拿掉最后一块石头的人就是获胜者。假设你们每一步都是最优解。请编写一个函数，来判断你是否可以在给定石头数量为n的情况下赢得游戏。如果可以赢，返回true；否则，返回false。
【刷题宝典NO.3】
TheMyth142857的博客
10-20 703
输入：nums = [0,0,1,1,1,2,2,3,3,4] 输出：5, nums = [0,1,2,3,4] 解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。**输入：**nums = [3,2,2,3], val = 3 **输出：**2, nums = [2,2] **解释：**函数应该返回新的长度。
刷题必备宝典
Closure
03-16 415
基本操作 #include <bits/stdc++.h> 宏定义 #define FF(a,b) for(int a=0;a<b;a++) #define F(a,b) for(int a=1;a<=b;a++) #define LEN 200 #define INF ((1<<30)-1) #define bug(x) cout<<#x&lt...
【PAT刷题甲级】1057.Stack
C_greenbird的博客
09-19 174
1057 Stack (30 分) Stack is one of the most fundamental data structures, which is based on the principle of Last In First Out (LIFO). The basic operations include Push (inserting an element onto the top position) and Pop (deleting the top element). Now you
我是怎么学习的No.27
u010459192的博客
07-13 103
我是小蕉。今天分享分享我自己的学习经历，如果能帮到大家就更好了。目前我接触的领域只有两个，JAVA和大数据，所以也只能从这两个领域来跟大家分享学习的路径。当初没什么人指导...
Android开发：使用Viewpager模仿驾考宝典试卷答题界面
小五博客园
10-14 4550
目录 引言 效果图 一、activity页实现 二、activity对应的layout页面布局 三、ExamPaperNoAnswerDetailFragment页代码实现 四、ExamPaperNoAnswerDetailFragment页对应的layout页面 五、ExamPaperNoAnswerViewPagerAdapter代码实现 六、总结 引言 最近，公司...
PAT甲级刷题之路——1073
qq_43677396的博客
09-08 1149
开始刷题——PAT甲级1073PAT甲级秋季考试落败，为了保研，冲冲冲！！PAT1073 Scientific Notation原题如下题目意思GOGOGO!自己的想法答案反馈代码结语 PAT甲级秋季考试落败，为了保研，冲冲冲！！ 今年是第一年浙大保研需要机试，半路出家完全没有底，看了晴神宝典大概十天以后，今年去考了PAT甲级，然后意料之中的失败了。第一道题解决完素数和最大公约数的问题以后只会用暴...
程序员进阶宝典
weixin_70730532的博客
05-12 133
前言 Spring 也算有多年的历史了，已成为 Java 应用程序开发框架的事实标准。在如此悠久的历史背景下，有人可能会认为 Spring 放慢了脚步，躺在了自己的荣誉簿上，再也做不出什么新鲜的东西，或者是让人激动的东西。甚至有人说，Spring 是遗留项目，是时候去看看其他创新的东西了。这些人说得不对。Spring 的生态圈里正在出现很多让人激动的新鲜事物，涉及的领域涵盖云计算、大数据、无模式的数据持久化、响应式编程以及客户端应用程序开发。而大厂面试更是年年不会落下问 SpringBoot，你还在怕搞不
《数据结构与算法 LeetCode刷题宝典V1.0》.pdf
05-03
为了大家学习的方便，所以把自己学习LeetCode的题目按照五种技巧，整理了这份150多页的小册子。可以作为学习数据结构与算法或备考计算机类研究生的参考资料，希望对大家有所帮助。
程序员面试宝典.zip
02-09
程序员面试宝典.zip
高等代数葵花宝典新版.pdf
07-26
初等代数从最简单的一元一次方程开始，初等代数一方面进而讨论二元及三元的一次方程组，另一方面研究二次以上及可以转化为二次的方程组。沿着这两个方向继续发展，代数在讨论任意多个未知数的一次方程组，也叫线性...
算法力扣刷题记录六【203移除链表元素】
danaaaa的博客
06-21 1089
删除链表节点
189.二叉树：将有序数组转换为二叉搜索树（力扣）
weixin_63779802的博客
06-21 217
代码使用了递归的方法。主要思路是首先找到数组的中间元素，然后以这个中间元素作为根节点，递归地在数组中构建左右子树。左子树包含数组中所有小于中间元素的元素，右子树包含所有大于中间元素的元素。这个算法的时间复杂度是 O(n)，其中 n 是数组中元素的数量。空间复杂度也是 O(n)，因为需要存储递归调用的栈。
面试+算法之回文(Java)：验证回文串、回文数、最长回文子串、回文链表、分割成回文串、最短回文串、
lonelymanontheway的博客
06-20 532
验证回文串、回文数、最长回文子串、分割成回文串、最短回文串、回文链表
【算法】二叉树 - 理论基础
最新发布
Nanki_的博客
06-23 1133
int val;
阿里巴巴-电子商务操作宝典new.ppt
11-12
阿里巴巴-电子商务操作宝典new是一份关于电子商务推广的宝典，其中包含了买家找到线索的方法、让买家更容易找到你的简便方法以及电子商务推广的三要素等内容。这份宝典提供了一系列的操作技巧，帮助电子商务从业者更...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

TheMythWS

你的鼓励，我的动力。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值