【Java】分支结构习题

【Java】分支结构

这篇博客主要讲解几道我认为比较有代表性关于分支结构的编程题。

下面让我们开始吧！

题1 ：数字9 出现的次数

/**
 * 数字9 出现的次数
 * 编写程序数一下 1到 100 的所有整数中出现多少个数字9
 */

public static void main(String[] args) {
        int count = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 10 == 9){
                count++;
            }
            if(i / 10 == 9){
                count++;
            }
        }
        System.out.println(count);
    }

这道题主要就是要明确个位的9怎么判断，十位的9怎么判断，另外99是两个9.

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

/**
 * 计算分数的值
 * 计算1/1-1/2+1/3-1/4+1/5 …… + 1/99 - 1/100 的值。
 */

public static void main(String[] args) {
    double sum = 0;
    int flag = 1;
    for (int i = 1; i <= 100; i++) {
        sum += 1.0 / i * flag;
        flag = -flag;
    }
    System.out.println(sum);
}

这道题主要是观察题目的规律，定义一个flag来实现正负的循环。

题3 ：猜数字

/**
 * 实现猜数字游戏
 * 完成猜数字游戏   ，用户输入数字，判断该数字是大于，小于，还是等于随机生成的数字，等于的时候退出程序。
 */

public static void main(String[] args) {
        Random random = new Random();
        Scanner sc = new Scanner(System.in);
        int guess = random.nextInt(100);
        while(true){
            System.out.println("请输入0-100的数字：>");
            int num = sc.nextInt();
            if(num < guess){
                System.out.println("猜小了");
            }else if(num > guess){
                System.out.println("猜大了");
            }else {
                System.out.println("猜对了！");
                break;
            }
        }
        sc.close();
    }

这道题前提是需要了解random的使用，其次的条件判断语句按正常逻辑编写即可。见以下文章：

Java生成随机数

题4 ：牛客BC110 X图案

X形图案

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的X形图案。
输入描述：
多组输入，一个整数（2~20），表示输出的行数，也表示组成“X”的反斜线和正斜线的长度。
输出描述：
针对每行输入，输出用“*”组成的X形图案。
 输入：
 5
 输出：
  *   *
   * *
    *
   * *
  *   *
 

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 == j || i + j == n - 1) {
                        System.out.print("*");
                    }else {
                        System.out.print(" ");
                    }
                }
                System.out.print("\n");
            }
            break;
        }

    }

这道题我们可以知道X是一个对称图形，所以X形图案可以拆分成两根斜线，其中i == j 时输出星号，或者i==n-i-1时输出星号即可，其他情况皆输出空格。

重点就在于i == j || i + j == n - 1这段。

题5 ：输出一个整数的每一位

/**
 * 输出一个整数的每一位
 * 输出一个整数的每一位，如：123的每一位是3，2，1
 */

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        while(num != 0){
            System.out.println(num%10);
            num/=10;
        }
    }

题6 ： 模拟三次密码输入

/**
 * 编写代码模拟三次密码输入的场景。 最多能输入三次密码，密码正确，提示“登录成功”,
 * 密码错误， 可以重新输 入，最多输入三次。三次均错，则提示退出程序
 */

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int count = 3;
        while (count != 0){
            System.out.println("请输入您的密码：>");
            String password = sc.nextLine();
            if(password.equals("123")){
                System.out.println("登陆成功！");
                break;
            }else {
                count--;
                System.out.println("请重新输入密码:> 还有"+count+"次机会");
            }
        }
    }

这道题逻辑其实很明确，我更想聊一聊的是String中==与equals的区别

• ==：
  在比较对象时比较的是引用地址是否相同；
  在比较基本类型时比较的是其内容。
• equals：
  比较的是内容，而不比较其引用。

见以下示例代码:

String s1 = new String("aaa");
String s2 = new String("aaa");
// s1与s2不是同一个对象
System.out.println(s1==s2);            //false
System.out.println(s1.equals(s2));    //true

String s1 = new String("aaa");
String s2 = s1;
//s1和s2是同一个地址的引用
System.out.println(s1==s2);            //true
System.out.println(s1.equals(s2));    //true

String s1 = "aaa";
String s2 = "aaa";
// s1与s2是类似类型
System.out.println(s1==s2);            //true
System.out.println(s1.equals(s2));    //true

针对第三示例代码,有以下想说的：

• 直接等号赋值是放入内存池的，其它变量也可以引用；

• new初始化分配内存空间，不可引用。

  String s=”a”和String s=new String(“a”)是有本质上的区别的。

  前者是在字符串池里写入一个字符’a’,然后用s指向它；

  后者是在堆上创建一个内容为”a”的字符串对象。
  如果String缓冲池内不存在与其指定值相同的String对象，那么此时虚拟机将为此创建新的String对象，并存放在String缓冲池内。

  如果String缓冲池内存在与其指定值相同的String对象，那么此时虚拟机将不为此创建新的String对象，而直接返回已存在的String对象的引用。

题7：求整数的最大公约数

/**
 * 求2个整数的最大公约数
 * 给定两个数，求这两个数的最大公约数
 * 例如：
 * 输入：20 40
 *
 * 输出：20

这里要介绍一种算法：辗转相除法

辗转相除法（也称为欧几里得算法）是一种用于求解两个整数的最大公约数的算法。它的步骤如下：

1. 将两个整数 a 和 b 作为输入。
2. 计算 a 除以 b 的余数，将结果保存为 r。
3. 如果 r 等于 0，则 b 即为最大公约数，算法结束。
4. 如果 r 不等于 0，则令 a 等于 b，b 等于 r，然后返回第2步。

这个过程会一直重复，直到余数为0。最后的 b 就是输入整数 a 和 b 的最大公约数。

public static void main(String[] args) {
        Scanner sc1 = new Scanner(System.in);
        Scanner sc2 = new Scanner(System.in);
        System.out.println("请输入两个数字：>");
        int a = sc1.nextInt();
        int b = sc2.nextInt();
        int c = a % b;
        while(c != 0){
            a = b;
            b = c;
            c =a % b ;
        }
        System.out.println(b);
    }

题8 ：获取一个二进制序列中的所有偶数位和奇数位，分别输出二进制序列

1. 提取所有的奇数位，如果该位是1，输出1，是0则输出0

2. 以同样的方式提取偶数位置

检测num中某一位是0还是1的方式：

1. 将num向右移动i位

2. 将移完位之后的结果与1按位与，如果：

结果是0，则第i个比特位是0

结果是非0，则第i个比特位是1

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();
    //0000 0010
    for (int i = 31; i >= 1 ; i-=2) {
        System.out.print(((n>>>i) & 1) + " " );
    }
    System.out.println();
    for (int i = 30; i >= 0 ; i-=2) {
        System.out.print(((n>>>i) & 1) + " " );
    }
}

//获取一个二进制序列中的所有偶数位和奇数位，分别输出二进制序列
    //eg:2的二进制序列位10 偶数位：1 奇数位：0
    //   4的二进制序列位100 偶数位：0 奇数位：1 0
    public static void main(String[] args) {
         Scanner scanner=new Scanner(System.in);
         int n=scanner.nextInt();
         int []arr=new int[16];//用于存放奇数位，一个数32位，奇/偶数位最高16位
         int []brr=new int [16];//用于存放偶数位
         int i=0;
         int j=0;
         int k=0;
         for(i=1;i<=32;i++)//获取输入数的末位数字
         {
             if(i%2!=0)//奇数位
             {
                 arr[j]=n&1;
                 //比如n=1010，n&1
                 //   1=0001
                 // n&1=0000=0，获取到了n的末位
                 j++;
                 n>>>=1;//无符号右移
             }
             else
             {
                 brr[k]=n&1;
                 k++;
                 n>>>=1;
             }
         }
        System.out.println("现打印奇数位：");
         for(i=0;i<16;i++)
         {
             System.out.print(arr[15-i]+" ");
         }
        System.out.println();
        System.out.println("现打印偶数位：");
        for(i=0;i<16;i++)
        {
            System.out.print(brr[15-i]+" ");
        }
    }