第四章练习题

分析：

通过控制台输入一个数字，编写函数，利用公式将该数字进行拆分求和，返回最终值。

import java.util.Scanner;
class Demo04_01{
    public static void main(String[] args){
        //1.先输入一个数字
        Scanner scanner=new Scanner(System.in);
        System.out.print("请输入一个数字:");
        long num=scanner.nextLong();
        //2.调用函数将num拆分求和
        int sum=sumDigits(num);
        System.out.println(sum);
    }
    public static int sumDigits(long n){
        int sum=0;
        while(true){
            sum+=n%10;
            n/=10;
            if(n==0){
                return sum;
            }
        }
    }
}

分析：

在控制台输入一个数字，编写函数计算该数字的反序，如果该数字反序和该数字相等，则返回ture输出是回文，否则返回false输出不是回文。

import java.util.Scanner;
class Demo04_02{
    public static void main(String[] args){
        //1.提示用户输入一个数字
        Scanner scanner=new Scanner(System.in);
        System.out.print("请输入一个数字:");
        int num=scanner.nextInt();
        //2.判断该数字是否是一个回文
        if(isPalindrome(num)){  // pause1
            System.out.println("是回文");
        }else{
            System.out.println("不是回文");
        }
        //return ;
    }
    public static boolean isPalindrome(int num){
        //1.先计算该数字的反序
        //2.对比反序的数字和数字本身
        return reverse(num)==num; 
    }
    public static int reverse(int num){
        int sum=0;
        while(true){
            sum=sum*10+num%10;
            num/=10;
            if(num==0){
                return sum;
            }
        }
    }
}

分析：

通过控制台输入想要打印的行数，编写函数，利用for循环编写金字塔。在主函数中调用该函数输出金字塔。

import java.util.Scanner;
class Demo04_03{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.print("请输入行数：");
        displayPattern(scanner.nextInt());
    }
    public static void displayPattern(int line){
        for(int i=1;i<=line;i++){              //行数为Line
            for(int k=1;k<=line-i;k++){        //空格变化
                if(line<10){ 
                    System.out.print("  ");
                }else{
                    System.out.print("   ");
                }
            }
            for(int j=i;j>=1;j--){             //数字变化
                if(line<10){
                    System.out.printf("%-2d",j);
                }else{
                    System.out.printf("%-3d",j);
                }
            }
            System.out.println();
        }
    }
}

import java.util.Scanner;
class Demo04_04{
    public static void main(String[] args){
        //1.先提示用户输入密码(String password)
        Scanner scanner=new Scanner(System.in);
        System.out.print("请输入密码:");
        String password=scanner.nextLine();

        //2.将密码传入 boolean isValid(password)
        if(isValid(password)){
            System.out.println("密码合法!");
        }else{
            System.out.println("密码不合法!");
        }
    }
    //3.isValid()
    //3.1 长度 isLengthValid()
    //3.2 组成 isContentValid()
        //3.2.1 isLetter(c) 判断该字符是否为字母字符
        //3.2.2 isDigit(c) 判断该字符是否为数字字符
    //3.3 特殊至少俩数字 isNumberValid() isDigit(c)
    public static boolean isValid(String s){
        return isLengthValid(s)&&isContentValid(s)&&isNumberValid(s);
    }
    public static boolean isLengthValid(String s){
        return s.length()>=8;
    }
    public static boolean isContentValid(String s){
        char c=' ';
        for(int i=0;i<s.length();i++){
            c=s.charAt(i);
            if(!isLetter(c)&&!isDigit(c)){
                return false;
            }
        }
        return true;
    }
    public static boolean isNumberValid(String s){
        int count=0;
        char c=' ';
        for(int i=0;i<s.length();i++){
            c=s.charAt(i);
            if(isDigit(c)){
                count++;
            }
        }
        return count>=2;
    }
    // a~z A~Z 只需要比较ASCII值
    // 'a'<=c<='z' || 'A'<=c<='Z'
    // '0'<=c<='9'
    public static boolean isLetter(char c){
        return c>='a'&&c<='z' || c>='A'&&c<='Z';
    }
    public static boolean isDigit(char c){
        return c>='0'&&c<='9';
    }

}

 

分析：

编写函数，利用公式计算，直到Math.abs(nextGuess-lastGuess)<0.00001，则此时返回nextGuess值。

class Demo04_05{
    public static void main(String[] args){
        System.out.println(sqrt(9));
    }
    public static double sqrt(long n){
        double lastGuess=1;                         //lastGuess初始值为1
        double nextGuess=(lastGuess+n/lastGuess)/2;
        while(true){                                //进入函数，反复计算，求出nextGuess
            if(Math.abs(nextGuess-lastGuess)<0.00001){
                return nextGuess;
            }
            lastGuess=nextGuess;
            nextGuess=(lastGuess+n/lastGuess)/2;
        }
    }
}

分析：

一共编写三个函数，一个判断是否为素数，一个判断是否为回文，最后一个判断他们两个是否同时满足，若是，返回ture，否则返回false。

class Demo04_06{
    public static void main(String[] args){
        int count=0;    //表示回文素数的个数
        int num=2;      //表示可能的回文素数的数字 从2开始~?
        while(true){
            //如果num是 回文素数
            if(isHuiWenAndSuShu(num)){
                count++;
                System.out.print(num+" ");
                if(count%10==0){
                    System.out.println();
                }
            }
            if(count==100){
                break;
            }
            num++;
        }
    }
    public static boolean isHuiWenAndSuShu(int num){//判断书否为回文素数
        return isHuiWen(num)&&isSuShu(num);
    }
    public static boolean isHuiWen(int num){
        return reverse(num)==num;
    }
    public static int reverse(int num){      //判断是否是回文
        int sum=0;
        while(true){
            sum=sum*10+num%10;
            num/=10;
            if(num==0){
                return sum;
            }
        }
    }
    public static boolean isSuShu(int num){   //判断是否是素数
        for(int i=2;i<=num/2;i++){
            if(num%i==0){
                return false;
            }
        }
        return true;
    }
}

分析：

编写函数四个函数，第一个判断一个数字是否是非回文，第二个判断该数字是否为素数，第三个判断该数字反转过后是否还为素数，

最后编写函数判断三者是否同时满足，是则返回该数字，反复运算，直到计数够100个，利用换行每十个一行输出。

class Demo04_07{
    public static void main(String[] args){
        int count=0;
        int num=2;
        while(true){
            if(isFanZhuanSuShu(num)){
                count++;
                System.out.print(num+" ");
                if(count%10==0){
                    System.out.println();
                }
            }
            if(count==100){
                return; //结束当前函数
            }
            num++;
        }
    }
    //1.本身是素数
    //2.反转之后也是素数
    //3.不能是回文
    //素数()  反转() 回文功能()
    public static boolean isFanZhuanSuShu(int num){
        return isSuShu(num)&&isSuShu(reverse(num))&&!isHuiWen(num);
    }
    //回文功能
    public static boolean isHuiWen(int num){
        return reverse(num)==num;
    }
    //素数功能
    public static boolean isSuShu(int num){
        for(int i=2;i<=num/2;i++){
            if(num%i==0){
                return false;
            }
        }
        return true;
    }
    //反转功能
    public static int reverse(int num){
        int sum=0;
        while(true){
            sum=sum*10+num%10;
            num/=10;
            if(num==0){
                return sum;
            }
        }
    }
}

class Demo04_08{
    public static void main(String[] args){
        String s="abcasjdjhsadadbhasdvasbd";
        System.out.println(count(s,'a'));
    }
    public static int count(String s,char c){
        int count=0;
        for(int i=0;i<s.length();i++){
            if(s.charAt(i)==c){
                count++;
            }
        }
        return count;
    }
}

class Demo04_09{
    public static void main(String[] args){
        String s="123456";
        System.out.println(reverse(s));
    }
    public static String reverse(String s){
        String res="";
        for(int i=s.length()-1;i>=0;i--){
            res+=s.charAt(i);
        }
        return res;
    }
}

class Demo04_10{
    public static void main(String[] args){
        String s="Welcome To China";
        System.out.println(getUpperCase(s));
    }
    public static int getUpperCase(String s){
        int count=0;
        for(int i=0;i<s.length();i++){
            if(isUpperCase(s.charAt(i))){
                count++;
            }
        }
        return count;
    }
    public static boolean isUpperCase(char c){
        return c>='A'&&c<='Z';
    }
}

class Demo04_11{
    public static void main(String[] args){
        String s1="Welcome";
        String s2="Welcome";
        System.out.println(getCommonPrefix(s1,s2));
    }
    public static String getCommonPrefix(String s1,String s2){
        /*
        String minStr="";
        String maxStr="";
        if(s1.length()<=s2.length()){
            minStr=s1;
            maxStr=s2;
        }else{
            minStr=s2;
            maxStr=s1;
        }
        for(int i=0;i<minStr.length();i++){
            if(minStr.charAt(i)!=maxStr.charAt(i)){
                return minStr.substring(0,i);
            }
        }
        return minStr;
        */
        int pa=0;// s1的指针
        int pb=0;// s2的指针
        while(true){
            if(s1.charAt(pa)!=s2.charAt(pb)){
                return s1.substring(0,pa);
            }
            if(s1.charAt(pa)==s2.charAt(pb)){
                pa++;
                pb++;
            }
            if(pa==s1.length()){
                return s1;
            }
            if(pb==s2.length()){
                return s2;
            }
        }
    }
}

class Demo04_12{
    public static void main(String[] args){
        String s="AB8C";
        //A B 8 C
        //0 1 2 3
        //3 2 1 0
        System.out.println(hexToDeimal(s));
    }
    public static int hexToDeimal(String s){
        int num=0;
        char c=' ';
        for(int i=0;i<s.length();i++){
            c=s.charAt(s.length()-1-i);
            /*
            A=10 B=11 C=12 D=13 E=14 F=15
            i=0 C C*16^0
            i=1 8 8*16^1
            i=2 B B*16^2
            i=3 A A*16^3
            */
            if(isLetter(c)){
                num+=(c-'A'+10)*Math.pow(16,i);
            }else{
                num+=(c-'0')*Math.pow(16,i);
            }
        }
        return num;
    }
    public static boolean isLetter(char c){
        return c>='A'&&c<='F';
    }
}