【刷题宝典NO.0】

news2024/11/25 13:43:44

目录

素数的判定

打印素数

打印水仙花数 

百钱买百坤

输出闰年

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

输出乘法口诀表 

数字9出现的次数 

二进制1的个数 

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

求两个整数的最大公约数 

求两个整数的最小公倍数 

小乐乐与欧几里得

小乐乐与进制转换

计算分数的值

计算求和

数列求和 

打印各种图案

打印长方形

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

打印空心正方形

打印 X 图形 

打印平行四边形

打印三角形

打印菱形

打印空心菱形 

小乐乐走台阶

斐波那契数列 

递归实现n的k次方 

递归求 N 的阶乘

递归求和 

递归打印数字的每一位 

返回的数字之和 

素数的判定

题目内容：

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

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

输出闰年

题目内容：
输出 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

递归实现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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1161369.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

C#，数值计算——积分方程与逆理论Quad_matrix的计算方法与源程序

C#，数值计算——积分方程与逆理论Quad_matrix的计算方法与源程序

1 文本格式 using System; namespace Legalsoft.Truffer { public class Quad_matrix : UniVarRealMultiValueFun { private int n { get; set; } private double x { get; set; } public Quad_matrix(double[,] a) { this.n a…
阅读更多...
适用于 Linux 的 WPF：Avalonia

适用于 Linux 的 WPF：Avalonia

许多年前&#xff0c;在 WPF 成为“Windows Presentation Foundation”并将 XAML 作为 .NET、Windows 等的 UI 标记语言引入之前&#xff0c;有一个代号为“Avalon”的项目。Avalon 是 WPF 的代号。XAML 现在无处不在&#xff0c;XAML 标准是一个词汇规范。 Avalonia 是一个开…
阅读更多...
精品Python空巢老人志愿服务平台慈善捐赠活动报名

精品Python空巢老人志愿服务平台慈善捐赠活动报名

《[含文档PPT源码等]精品基于Python的空巢老人志愿服务平台》该项目含有源码、文档、PPT、配套开发软件、软件安装教程、项目发布教程、包运行成功&#xff01; 软件开发环境及开发工具&#xff1a; 开发语言&#xff1a;python 使用框架&#xff1a;Django 前端技术&#…
阅读更多...
EasyExcel复杂表头数据导入

EasyExcel复杂表头数据导入

目录 表头示例导入代码数据导出 表头示例 导入代码 Overridepublic void importExcel(InputStream inputStream) {ItemExcelListener itemExcelListener new ItemExcelListener();EasyExcel.read(inputStream, ImportItem.class, itemExcelListener).headRowNumber(2).sheet()…
阅读更多...
【蓝桥每日一题]-二分类型（保姆级教程 篇2） #砍树 #木材加工

【蓝桥每日一题]-二分类型（保姆级教程 篇2） #砍树 #木材加工

今天讲二分的例题&#xff0c;一道是“砍树”&#xff0c;一道是“木材加工” 目录 题目&#xff1a;砍树 思路1&#xff1a; 思路2&#xff1a; 题目&#xff1a;木材加工 思路&#xff1a; 题目&#xff1a;砍树 思路1&#xff1a; 二分查找&#xff1a;对高度进行二分 二…
阅读更多...
关注云栖大会的感受：从工业大脑到全面AI时代的进化

关注云栖大会的感受：从工业大脑到全面AI时代的进化

前言 自2009年的地方网站峰会到如今的云栖大会&#xff0c;这个盛大的科技盛事已经走过了一个多十年的漫长历程。这个会议见证了中国科技行业的崛起&#xff0c;也记录了技术的不断演化。而对我来说&#xff0c;首次接触云栖大会是在2020年&#xff0c;当年大会迁移到线上&…
阅读更多...
从零开发基于ASM字节码的Java代码混淆插件XHood

从零开发基于ASM字节码的Java代码混淆插件XHood

项目背景 因在公司负责基础框架的开发设计&#xff0c;所以针对框架源代码的保护工作比较重视&#xff0c;之前也加入了一系列保护措施 例如自定义classloader加密保护&#xff0c;授权license保护等&#xff0c;但都是防君子不防小人&#xff0c;安全等级还比较低 经过调研…
阅读更多...
【密评】商用密码应用安全性评估从业人员考核题库（十七）

【密评】商用密码应用安全性评估从业人员考核题库（十七）

商用密码应用安全性评估从业人员考核题库&#xff08;十七&#xff09; 国密局给的参考题库5000道只是基础题&#xff0c;后续更新完5000还会继续更其他高质量题库&#xff0c;持续学习&#xff0c;共同进步。 4001 多项选择题 网络和通信安全层面的通信主体一般包括哪些&…
阅读更多...
基于Docker-consul容器服务更新与发现

基于Docker-consul容器服务更新与发现

目录 一、什么是服务注册与发现&#xff1a; 二、Docker-consul介绍&#xff1a; 三、consul的关键特性&#xff1a; 四、consul部署&#xff1a; 1.部署规划&#xff1a; 2.consul服务器部署&#xff1a; 2.1 建立consul服务&#xff1a; 启动consul后默认会监听5个端口&a…
阅读更多...
管理双因素身份验证的Web应用2FAuth

管理双因素身份验证的Web应用2FAuth

什么是 2FAuth &#xff1f; 2FAuth 是一种基于 Web 的自托管替代方案&#xff0c;可替代 Google Authenticator 等一次性密码 (OTP) 生成器&#xff0c;专为移动设备和桌面设备设计。 近年来&#xff0c;双因素身份验证变得非常流行&#xff0c;2FA 现在是不可避免且至关重要的…
阅读更多...
阿里云ECS经济型e实例ecs.e-c1m1.large性能测评

阿里云ECS经济型e实例ecs.e-c1m1.large性能测评

阿里云服务器ECS经济型e实例2核2G配置规格ecs.e-c1m1.large&#xff0c;CPU采用Intel Xeon Platinum架构处理器&#xff0c;e系列云服务器是阿里云面向个人开发者、学生、小微企业&#xff0c;在中小型网站建设、开发测试、轻量级应用等场景推出的全新入门级云服务器。目前云服…
阅读更多...
C++ 类型

C++ 类型

4.5//默认double类型 4.5f//float类型 基本内置类型 基本内置类型包含算术类型和空类型&#xff0c;算术类型包含字符、整数型、布尔值和浮点数&#xff0c;空类型不对应具体的值&#xff0c;仅用于一些特殊的场合。 算术类型 分为两类&#xff0c;整型&#xff08;包括字…
阅读更多...
艾奇免费KTV电子相册视频制作软件

艾奇免费KTV电子相册视频制作软件

不得不承认功能特色支持添加导入图形、视频、歌曲、卡啦ok动态歌词字幕文件&#xff1a;图形文件格式支持导入jpg/jpeg/png/bmp/gif等静态图形&#xff1b;视频文件支持导入AVI/MP4/FLV/MTS/MPG/RMVB等几乎所有常见视频文件&#xff1b;歌曲格式支持mp3/wma/acc/ogg/wav等几乎所…
阅读更多...
力扣第96题 不同的二叉搜索树 c++ 二叉搜索树 动态规划 + 数学思维

力扣第96题 不同的二叉搜索树 c++ 二叉搜索树 动态规划 + 数学思维

题目 96. 不同的二叉搜索树 中等 相关标签 树 二叉搜索树 数学 动态规划 二叉树 给你一个整数 n &#xff0c;求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种&#xff1f;返回满足题意的二叉搜索树的种数。 示例 1&#xff1a; 输入&#…
阅读更多...
NoSQL数据库使用场景以及架构介绍

NoSQL数据库使用场景以及架构介绍

文章目录 一. 什么是NoSQL&#xff1f;二. NoSQL分类三. NoSQL与关系数据库有什么区别四. NoSQL主要优势和缺点五. NoSQL体系框架 其它相关推荐&#xff1a; 系统架构之微服务架构 系统架构设计之微内核架构 鸿蒙操作系统架构 架构设计之大数据架构&#xff08;Lambda架构、Kap…
阅读更多...
Halo勒索病毒：了解最新变种.halo，以及如何保护您的数据

Halo勒索病毒：了解最新变种.halo，以及如何保护您的数据

导言&#xff1a; 在当今数字化的世界中&#xff0c;网络威胁不断演变&#xff0c;其中勒索病毒一直是网络犯罪分子的有力武器之一。在这篇文章中&#xff0c;我们将深入介绍.halo勒索病毒&#xff0c;了解它的工作方式&#xff0c;讨论如何恢复被加密的数据文件&#xff0c;并…
阅读更多...
【网络协议】聊聊HTTPS协议

【网络协议】聊聊HTTPS协议

前面的文章&#xff0c;我们描述了网络是怎样进行传输数据包的&#xff0c;但是网络是不安全的&#xff0c;对于这种流量门户网站其实还好&#xff0c;对于支付类场景其实容易将数据泄漏&#xff0c;所以安全的方式是通过加密&#xff0c;加密方式主要是对称加密和非对称加密。…
阅读更多...
vue3简单写导航anchor示例(支持点击高亮和滚动判断高亮)

vue3简单写导航anchor示例(支持点击高亮和滚动判断高亮)

1. 点击anchor, 相应的anchorlink高亮 function anchorClick(index) { forceStop.value true; time Date.now(); wheelRef.value.children[index].scrollIntoView({ block: start, behavior: smooth }); // 给一些延时, 再点亮anchor, 同时不再限制scrol…
阅读更多...
【教3妹学编辑-算法题】环和杆

【教3妹学编辑-算法题】环和杆

3妹&#xff1a;2哥&#xff0c;今年春节的放假安排出来了&#xff0c;今年春节放8天假&#xff0c;我们公司除夕提前放一天&#xff0c;总共9天假。 耶~~~ 2哥 :你们公司这么好啊&#xff0c; 我们公司的放假安排还没出来&#xff0c;不知道今年除夕能不能回家了… 3妹&#x…
阅读更多...
（免费领源码）Java#MYSQL超市管理系统10428-计算机毕业设计项目选题推荐

（免费领源码）Java#MYSQL超市管理系统10428-计算机毕业设计项目选题推荐

目 录 摘要 1 绪论 1.1 研究意义 1.2国内外研究现状 1.3论文结构与章节安排 2 超市管理系统系统分析 2.1 可行性分析 2.2 系统流程分析 2.2.1 数据流程 3.3.2 业务流程 2.3 系统功能分析 2.3.1 功能性分析 2.3.2 非功能性分析 2.4 系统用例分析 2.5本章小结 3 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023