8初级 - Java的运算系统-练习

8-1

8-1-1

package com.github.hcsp.calculation;

public class Solution {
    public static void main(String[] args) {
        // 结果应该是4
        System.out.println(calculate(100));
    }

    // 1.首先将该数字加1
    // 2.将上一步的结果乘以2
    // 3.将上一步的结果减3
    // 4.将上一步的结果除以4
    // 5.将上一步的结果对5取余
    // 将得到的结果返回
    public static int calculate(int number) {
        return ((number + 1) * 2 - 3) / 4 % 5;
    }
}

8-1-2

package com.github.hcsp.calculation;

import java.util.Arrays;

public class Solution {
    public static void main(String[] args) {
        System.out.println("x^2-2x+1=0的解是：" + Arrays.toString(calculate(1, -2, 1)));
        System.out.println("x^2-4=0的解是：" + Arrays.toString(calculate(1, 0, -4)));
        System.out.println("x^2+1=0的解是：" + Arrays.toString(calculate(1, 0, 1)));
    }

    // 计算一元二次方程ax^2+bx+c=0的根。
    // 若有两个根，返回一个数组，包含这两个根，即：new double[] { root1, root2 }
    // 若有一个根，返回一个数组，包含这个根，即：n返回new double[] { root }
    // 若没有根，返回一个空数组，即：new double[] {}
    // 提示，你可利用求根公式x=[-b±√(b²-4ac)]/2a
    // 需要执行开方运算时可使用Math.sqrt()方法
    public static double[] calculate(int a, int b, int c) {
        double p4 = b * b - 4 * a * c;
        if (p4 < 0) {
            return new double[] {};
        } 
        int p1 = -b;
        double p2 = Math.sqrt(p4);
        int p3 = 2 * a;
        double result1 = (p1 + p2) / p3;
        double result2 = (p1 - p2) / p3;
        if (result1 == result2) {
            return new double[] { result1 };
        } else {
            return new double[] { result1, result2 };
        }
    }
}

8-2

8-2-1

package com.github.hcsp.calculation;

public class Solution {
    public static void main(String[] args) {
        printNumberTo10(9);
    }

    // 打印从number开始到10的数字
    // 例如，number=6，则打印6,7,8,9,10
    // 例如，number=9，则打印9,10
    // 现在输出的结果和预期不符，请修复此问题
    public static void printNumberTo10(int number) {
        while (true) {
            System.out.println(number++);
            if (number > 10) {
                return;
            }
        }
    }
}

8-3

8-3-1

package com.github.hcsp.calculation;

public class Solution {
    public static void main(String[] args) {
        System.out.println("A是合法的十六进制字符:" + isValidHexCharacter('A'));
        System.out.println("0是合法的十六进制字符:" + isValidHexCharacter('0'));
        System.out.println("G是合法的十六进制字符:" + isValidHexCharacter('G'));
    }

    // 一个合法的十六进制的字符是：字符0-9，以及字符A/a/B/b/C/c/D/d/E/e/F/f （大小写都是合法的）
    // 编写一个方法，给定一个字符，若是合法的十六进制字符，返回true，否则返回false
    public static boolean isValidHexCharacter(char ch) {
        if ( ch == 'A' ) {
            return true;
        }else if ( ch == 'a' ){
            return true;
        }else if ( ch == 'B' ){
            return true;
        }else if ( ch == 'b' ){
            return true;
        }else if ( ch == 'C' ){
            return true;
        }else if ( ch == 'c' ){
            return true;
        }else if ( ch == 'D' ){
            return true;
        }else if ( ch == 'd' ){
            return true;
        }else if ( ch == 'E' ){
            return true;
        }else if ( ch == 'e' ){
            return true;
        }else if ( ch == 'F' ){
            return true;
        }else if ( ch == 'f' ){
            return true;
        }else if ( ch == '0' ){
            return true;
        }else if ( ch == '1' ){
            return true;
        }else if ( ch == '2' ){
            return true;
        }else if ( ch == '3' ){
            return true;
        }else if ( ch == '4' ){
            return true;
        }else if ( ch == '5' ){
            return true;
        }else if ( ch == '6' ){
            return true;
        }else if ( ch == '7' ){
            return true;
        }else if ( ch == '8' ){
            return true;
        }else if ( ch == '9' ){
            return true;
        }
        return false;

    }
}

8-4

8-4-1

package com.github.hcsp.calculation;

public class Cat {
    private static int CUTE = 0x1;
    private static int FAT = 0x2;
    private static int WHITE = 0x4;
    private int properties = 0;

    // ↑ 请勿修改以上部分的代码，请勿添加新的成员变量
    // ↓ 请补全以下代码

    /**
     * 使用位运算设置猫咪萌的属性
     *
     * @param cute true为萌，false为不萌
     */
    public void setCute(boolean cute) {
        if (cute == true) {
            properties = properties | CUTE;
        } else {
            properties = properties & (~CUTE);
        }
    }

    /**
     * 这只猫萌吗？请在此处使用位运算读取properties，得到猫是否萌的结果
     *
     * @return 萌则返回true，否则返回false
     */
    public boolean isCute() {
        return (properties & CUTE) != 0;
    }

    /**
     * 使用位运算设置猫咪胖的属性
     *
     * @param fat true为胖，false为不胖
     */
    public void setFat(boolean fat) {
        if (fat == true) {
            properties = properties | FAT;
        } else {
            properties = properties & (~FAT);
        }
    }

    /**
     * 这只猫胖吗？请在此处使用位运算读取properties，得到猫是否胖的结果
     *
     * @return 胖则返回true，否则返回false
     */
    public boolean isFat() {
        return (properties & FAT) != 0;
    }

    /**
     * 使用位运算设置猫咪白的属性
     *
     * @param white true为白，false为不白
     */
    public void setWhite(boolean white) {
        if (white == true) {
            properties = properties | WHITE;
        } else {
            properties = properties & (~WHITE);
        }
    }

    /**
     * 这只猫白吗？请在此处使用位运算读取properties，得到猫是否白的结果
     *
     * @return 白则返回true，否则返回false
     */
    public boolean isWhite() {
        return (properties & WHITE) != 0;
    }

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.setCute(true);
        cat.setFat(true);
        cat.setWhite(false);
        System.out.println("这只猫萌吗：" + cat.isCute());
        System.out.println("这只猫胖吗：" + cat.isFat());
        System.out.println("这只猫白吗：" + cat.isWhite());
    }
}

8-4-2

package com.github.hcsp.calculation;

public class Main {
    // 返回number乘以16的结果
    // 请不要使用乘号
    public static int multiply16(int number) {
        int number1 = number << 4;
        return number1;
    }
    // 返回number除以16的结果
    // 请不要使用除号
    public static int divide16(int number) {
        int number1 = number >> 4;
        return number1;
    }

    public static void main(String[] args) {
        System.out.println(multiply16(10));
        System.out.println(divide16(1600));
    }
}

8-5

8-5-1

package com.github.hcsp.calculation;

public class Main {
    /**
     * 输入学生姓名和分数，当： 90<=score<=100分时，返回"学生X的分数是Y，评级是A"；
     *
     * <p>60<=score<=89时，返回"学生X的分数是Y，评级是B"；
     *
     * <p>0<=score<=59时，返回"学生X的分数是Y，评级是C"；
     *
     * <p>score为其他值时，返回"非法输入"。
     *
     * @param student 学生的姓名
     * @param score 学生的分数
     * @return 结果字符串
     */
    public static String formatStudentScore(String student, int score) {
        String result = "";
        if((score<=100) && (score>=90)){
            result = "学生" + student + "的分数是" + score + "，评级是A";
        }else if((score<=89) && (score>=60)){
            result = "学生" + student + "的分数是" + score + "，评级是B";
        }else if((score<=59) && (score>0)){
            result = "学生" + student + "的分数是" + score + "，评级是C";
        }else {
            result = "非法输入";
        }
        return result;
    }

    public static void main(String[] args) {
        System.out.println(formatStudentScore("张三", -1));
        System.out.println(formatStudentScore("张三", 0));
        System.out.println(formatStudentScore("张三", 60));
        System.out.println(formatStudentScore("张三", 900));
    }
}

8-5-2

package com.github.hcsp.calculation;

public class Main {
    /**
     * 给定三个大小不确定的数字a,b,c，将其按照从大到小的顺序输出。
     *
     * <p>例如，a=1,b=3,c=2，返回字符串"3>2>1"。
     *
     * <p>又如，a=-1,b=100,c=4，返回字符串"100>4>-1"
     *
     * @param a 数字一
     * @param b 数字二
     * @param c 数字三
     * @return 所要求的字符串
     */
    public static String printNumbersInOrder(int a, int b, int c) {
        String result = "";
        if (a > b) {
            if (b > c) {
                result = a + ">" + b + ">" + c;
            }
            if (b < c) {
                if (a > c) {
                    result = a + ">" + c + ">" + b;
                } else {
                    result = c + ">" + a + ">" + b;
                }
            }
        } else {
            if (a > c) {
                result = b + ">" + a + ">" + c;
            } else {
                if (c > b) {
                    result = c + ">" + b + ">" + a;
                } else {
                    result = b + ">" + c + ">" + a;
                }
            }
        }
        return result;
    }

    public static void main(String[] args) {
        System.out.println(printNumbersInOrder(1, 2, 3));
        System.out.println(printNumbersInOrder(-1, 2, -3));
    }
}

8-5-3

package com.github.hcsp.calculation;

public class Main {
    // 连接两个字符串，如果字符串为空指针null，则将其当作空字符串处理
    // 现在的实现有明显的bug，请修复之。
    public static String concatString(String a, String b) {
        String result = "";
        if (a == null) {
            if (b == null) {
                result = "";
            } else {
                result = b;
            }
        } else {
            if (b == null) {
                result = a;
            } else {
                result = a + b;
            }
        }
        return result;
    }

    public static void main(String[] args) {
        System.out.println(concatString(null, null));
        System.out.println(concatString("a", null));
        System.out.println(concatString("a", "b"));
        System.out.println(concatString(null, "b"));
    }
}