java习题集2 | 易学教程

1、打印 2 到 1000 之间、包括 2 和 1000的所有素数，每行显示 8 个素数。数字之间用一个空格字符隔开。

/*
什么是素数 就是除了1和其本身之外 没有其他的数字可以整除的
num
2 ~ m ~ num-1 找到一个数字 如果这个数字m num%m==0 num不是素数
如果一个都没有找到的话 这个数字是素数

*/
public class A{
    public static void main(String[] args){
        int count=0;  //当前素数的个数
        boolean flag=true;
        for(int num=2;num<=1000;num++){
            for(int m=2;m<=num-1;m++){
                if(num%m==0){
                    flag=false;
                    break;
                }
            }
            if(flag){
                count++;
                System.out.print(num+" ");
                if(count%8==0){ //8 16 24 32
                    System.out.println();
                }
            }
            flag=true;
        }
    }
}
/*
int num=10;
        boolean flag=true;  //默认这个数字是素数
        for(int m=2;m<=num-1;m++){
            if(num%m==0){//说明num不是素数
                flag=false;//此时不是素数
                break;
            }
        }
        //如果for正常执行完毕 都没有找到 是素数
        // System.out.println("是素数");
        //重点就在于 for是如何退出的
        //如果for是break出来的 -> 不是素数
        //如果for是正常执行完毕的->是素数
        if(flag){
            System.out.println("是素数");
        }else{
            System.out.println("不是素数");
        }
*/

2、
在这里插入图片描述

import java.util.Scanner;
public class A{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.print("请输入一个数字：");
        int imax=scanner.nextInt();
        double sum=0;
        double flag=1;
        for(int i=1;i<=imax;i++){
            //sum+=Math.pow(-1.0,i+1);/(2*i-1);
            sum+=flag/(2*i-1);
            flag=-flag;
        }
        double pi=sum*4;
        System.out.println(pi);
        // 累乘 Math.pow(-1.0,i+1) for -1*-1*-1....
    }
}

3、
在这里插入图片描述

import java.util.Scanner;
public class A{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.print("请输入一个数字：");
        int imax=scanner.nextInt();
        double e=1;
        double item=1.0;
        for(int i=1;i<=imax;i++){
            item=item*i;    //n!=(n-1)*n;
            e+=1/item;
        }
        System.out.println(e);
    }
}

4、编写程序，显示从101到 2100 期间所有的闰年，每行显示10 个。数字之间用一个空格字符隔开，同时显示这期间闰年的数目。

public class A{
    public static void main(String[] args){
        int count=0;
        for(int i=101;i<=2100;i++){
            if(i%4==0&&i%100!=0 || i%400==0){
                count++;
                System.out.print(i+" ");
                if(count%10==0){
                    System.out.println();
                }
            }
        }
        System.out.println("\n闰年一共"+count+"个");
    }
}

5、如果一个正整数等于除它本身之外其他所有除数之和，就称之为完全数。例如：6 是第一个完全数，因为 6=1+2+3。下一个完全数是 28=14+7+4+2+1。10 000以下的完全数有四个。编写程序，找出这四个完全数。

public class A{
    public static void main(String[] args){
        //6 : 1 2 3 4 5 6
        //28: 1 2 4 7 14 
        //n : 1 ~ n/2
        int sum=0;
        for(int n=2;n<=10000;n++){   
            for(int i=1;i<=n/2;i++){
                if(n%i==0){
                    sum+=i;
                }
            }
            if(n==sum){
                System.out.println("完全数"+n);
            }
            sum=0;
        }
    }
}

6、给出玩石头、剪刀、布游戏的程序。让用户可以连续地玩这个游戏，直到用户或者计算机贏对手两次以上为止。

import java.util.*;
public class A{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        Random random=new Random();
        int usrWin=0;
        int comWin=0;
        while(true){
            System.out.print("请输入剪刀0 石头1布2：");
            int usr=scanner.nextInt();
            int com=random.nextInt(3);
            String usrStr = "";
            String comStr = "";
            switch(usr){
                case 0:
                    usrStr = "scissor"; 
                    break;
                case 1:
                    usrStr = "rock";
                    break;
                case 2:
                    usrStr = "paper";
                    break;
            }
            switch(com){
                case 0: 
                    comStr = "scissor"; 
                    break;
                case 1:
                    comStr = "rock";
                    break;
                case 2:
                    comStr = "paper";
                    break;
            }
            if(usr==com){
                System.out.printf("The computer is %s.you are %s too.It is a draw\n",comStr,usrStr);
            }else if(usr==0&&com==2 || usr==1&&com==0 || usr==2&&com==1){
                System.out.printf("The computer is %s.you are %s.You won\n",comStr,usrStr);
                usrWin++;
            }else{
                System.out.printf("The computer is %s.you are %s.You lost\n",comStr,usrStr);
                comWin++;
            }
            if(usrWin==2||comWin==2){
                break;
            }
        }
        if(usrWin==2){
            System.out.println("最终玩家赢！");
        }else{
            System.out.println("最终电脑赢！");
        }
    }
}

7、编写程序，提示用户输人一个十进制整数，然后显示对应的二进制值。在这
个程序中不要使用 Java 的 Interger.toBinaryString(int)方法。

/*
12/2 6 ~ 0
6/2  3 ~ 0
3/2  1 ~ 1
1/2  0 ~ 1
1100
*/
import java.util.Scanner;
public class A{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.print("请输入一个数字：");
        int num=scanner.nextInt();
        String binStr="";
        while(true){
            binStr=num%2+binStr;//"1100"
            num/=2;
            if(num==0){
                break;
            }
        }
        System.out.println(binStr);
    }
}

8、编写程序读取整数，找出它们的最大数，然后计算该数的出现次数。假设
输人是以 0结束的。假定输人是 3 5 2 5 5 5 0, 程序找出最大数 5, 而 5 出现的次数是 4。

import java.util.Scanner;
public class A{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        int num=0;
        int max=0;
        int count=0;
        System.out.print("请输入数字：");
        while(true){
            num=scanner.nextInt();
            if(num==0){
                break;
            }else if(num>max){
                max=num;
                count=1;
            }else if(num==max){
                count++;
            }
        }
        System.out.println("max="+max+",count="+count);
    }
}

9、编写一个方法，计算一个整数各位数字之和。使用下面的方法头：
public static int sumDigits(long n)
例如：sumDigits(234)返回 9(2+3+4)。

import java.util.Scanner;
public class A{
    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;
            }
        }
    }
}

10、使用下面的方法头编写两个方法：
public static int reverse(int number)
public static boolean isPalindrome(int number)
使用 reverse 方法实现 isPalindrome。如果一个数字的反向倒置数和它的顺向数一样，这个数就称作回文数。编写一个测试程序，提示用户输人一个整数值，然后报告这个整数是否是回文数。

import java.util.Scanner;
public class A{
    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.对比反序的数字和数字本身
                //pasue 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;
            }
        }
    }
}

11、
在这里插入图片描述

import java.util.Scanner;
public class A{
    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++){
            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();
        }
    }
}

12、一些网站对于密码具有一些规则。编写一个方法，检测字符串是否是一个有效密码。假定密码规则如下：
密码必须至少 8 位字符。
密码仅能包含字母和数字。
密码必须包含至少两个数字。
编写一个程序，提示用户输入一个密码，如果符合规则，则显示 Valid Password, 否则显示 Invalid Password。

import java.util.Scanner;
public class A{
    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';
    }

}

13、有几种实现 Math 类中 sqrt 方法的技术。其中一个称为巴比伦法。它通过使用下面公式的反复计算近似地得到：
nextCuess =(lastCuess + n / lastCuess) / 2
当 nextGuess 和 lastGuess 几乎相同时，nextGuess 就是平方根的近似值。最初的猜测值可以是任意一个正值（例如1)。这个值就是 lastCuess的初始值。如果 nextGUess 和lastGuess 的差小于一个很小的数，比如 0.0001, 就可以认为 nextGuess 是 n 的平方根的近似值；否则，nextGuess 就成为 lastGuess, 近似过程继续执行。实现下面的方法，返回 n 的平方根。

public class A{
    public static void main(String[] args){
        System.out.println(sqrt(9));
    }
    public static double sqrt(long n){
        double lastGuess=1;
        double nextGuess=(lastGuess+n/lastGuess)/2;
        while(true){
            if(Math.abs(nextGuess-lastGuess)<0.00001){
                return nextGuess;
            }
            lastGuess=nextGuess;
            nextGuess=(lastGuess+n/lastGuess)/2;
        }
    }
}

14、回文素教是指一个数同时为素数和回文数。例如：131是一个素数，同时也是一个回文素数。数字 313 和 757 也是如此。编写程序，显示前 100 个回文素数。每行显示 10 个数并且准确对齐，数字中间，空格隔开。如下所示：
2 3 5 7 11 101 131 151 181 191
313 3SB 373 383 727 7S7 787 797 919 929

public class A{
    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;
    }
}

15、反素教（反转拼写的素数）是指一个非回文素数，将其反转之后也是一个索数。例如：17 是一个素数，而 71也是一个索数，所以 17 和 71是反素数。编写程序，显示前 100 个反素数。每行显示 10 个，并且数字间用空格隔开，如下所示:
13 17 31 37 71 73 79 97 107 113
149 157 167 179 199 311 337 347 359 389

public class A{
    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;
            }
        }
    }
}

汉诺塔
汉诺塔是一个发源于印度的益智游戏，也叫河内塔。相传它源于印度神话中的大梵天创造的三个金刚柱，一根柱子上叠着上下从小到大64个黄金圆盘。大梵天命令婆罗门将这些圆盘按从小到大的顺序移动到另一根柱子上，其中大圆盘不能放在小圆盘上面。当这64个圆盘移动完的时候，世界就将毁灭。那么好多人会问64个圆盘移动到底会花多少时间？那么古代印度距离现在已经很远，这64个圆盘还没移动完么？我们将通过递归算法来计算来看看要完成这个任务到底要多少时间？
在这里插入图片描述
此题的解题思路是将三个盘子拆分成2组，将前两个看成一个，第三个看成一个，再将前两个解决，要把3个从X移到Z，先得把前两个从X 移到 Y，再把第三个从X移到Z，最后再把前两个从Y移到Z即可。

class Hanno{
    public static void main(String[] args){
        //盘子的个数 出发 中间 目的
        hanno(64,"X","Y","Z");
    }                                     
    public static void hanno(int n,String begin,String mid,String end){
        if(n==1){
            System.out.println(begin+" -> "+end);
        }else{
            hanno(n-1,begin,end,mid);
            System.out.println(begin+" -> "+end);
            hanno(n-1,mid,begin,end);
        }
    }
}
/*
最大的问题将X上的三个盘子放到Z上
3个 X->Z
    前2个 X->Y
        前1个 X->Z
        第2个 X->Y
        前1个 Z->Y
    第3个 X->Z
    前2个 Y->Z
        前1个 Y->X
        第2个 Y->Z
        前1个 X->Z
64个 X->Z
    前63个 X->Y
        前62个 X->Z

        第63个 X->Y
        前62个 Z->Y
    第64个 X->Z
    前63个 Y->Z
        前62个 Y->X
        第63个 Y->Z
        前62个 X->Z

*/

斐波那契数列 1 1 2 3 5 8 13 21 34 55 …
分析：f(n)=f(n-1)+f(n-2),其中，f(n)指的是数列的第n项，f(1)=1,f(2)=1
在这里插入图片描述

class Test02{
    public static void main(String[] args){
        //show();
        /*
        问题1：计算1+2+3+4+5+...+98+99+100
        f(n) 是求1~n的累加
        f(100)就是我们当前最大的问题
        写递归时，一定要先写它的end!
        ↓ 递
        f(n)=f(n-1)+n
        f(100)=f(99)+100    return 1+2+3+..+99 +100
        f(99)=f(98)+99      return 1+2+...+98 +99
        ...
        f(4)=f(3)+4         return 1+2+3+4
        f(3)=f(2)+3         return 1+2+3
        f(2)=f(1)+2         return 1+2
        f(1)=1              return 1
        → end               ↑ 归
        */
        System.out.println(f(10));
        /* 
        问题2：斐波那契数列 求前20项
        1 1 2 3 5 8 13 21 34 55 ......
        f(n)指的是斐波那契的第n项
        f(n)=f(n-1)+f(n-2) f(1)=1 f(2)=1
                  f(5)
            f(4)        f(3)
        f(3)    f(2) f(2)   f(1)
    f(2)    f(1)
        */
        //缺点 越往后 越慢 代码比较简洁
        //O(n*2^n)
        for(int i=1;i<=100;i++){//O(n)
            System.out.println(fibo(i));//O(2^n)
        }
        System.out.println("==============");
        fiboIterator(10000);//用迭代的思想求前20项
    }
    //O(n)线性级别
    public static void fiboIterator(int n){
        int a=1;
        int b=1;
        System.out.println(a);
        System.out.println(b);
        int count=2;
        int c;
        while(true){
            c=a+b;
            System.out.println(c);
            count++;
            if(count==n){
                return;
            }
            a=b;
            b=c;
        }
    }
    public static int fibo(int n){
        if(n==1||n==2){
            return 1;
        }
        return fibo(n-1)+fibo(n-2);
    }
    public static int f(int n){
        if(n==1){
            return 1;
        }
        return f(n-1)+n;
    }
    public static void show(){
        System.out.println("show....");
        show();
    }
}

17、使用下面的方法头编写一个方法，找到一个宇符串中指定字符的出现次数。
public static int count(String str, char a)
例如，count(“Welcome”,“e”), 返回 2.编写一个测试程序，提示用户输人一个字符串以及一个字符，显示该字符在字符串中出现的次数。

public class A{
    public static void main(String[] args){
        String s="Welcome";
        System.out.println(count(s,'e'));
    }
    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;
    }
}

18、编写一个程序，提示用户输入一个字符串，然后以反序显示该字符串。
例如:ABCD 输出:DCBA

public class A{
    public static void main(String[] args){
        String s="ABCD";
        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;
    }
}

19、编写一个程序，提示用户输人一个字符串，然后显示该字符串中大写字母的
数目。

public class A{
    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';
    }
}

20、编写一个程序，提示用户输人两个字符串，显示两个字符串最长的共同前缀。下面是运行示例
在这里插入图片描述

public class A{
    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;
            }
        }
    }
}

21、
在这里插入图片描述

public class A{
    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';
    }
}

22、编写程序，读取在1到 100 之间的整数，然后计算每个数出现的次数。
假定输入是以 0 结束的。下面是这个程序的一个运行示例：
在这里插入图片描述

import java.util.Scanner;
public class A{
    /*
    唯一的一个最重要难点的问题是 数组的长度怎么办？
    输出的数字顺序必须是有序的 排序
    思路1.来一个数字加一个数字(数组动态扩容)

    */
    public static void main(String[] args){
        int[] arr=new int[0];
        //1.读取元素将数据存放到数组中
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter numbers:");
        int num=0;
        while(true){
            num=scanner.nextInt();
            if(num==0){
                break;
            }
            arr=copyOf(arr,arr.length+1);
            arr[arr.length-1]=num;
        }
    }
    public static int[] copyOf(int[] arr,int newLen){
        int[] newArr=new int[newLen];
        for(int i=0;i<arr.length;i++){
            newArr[i]=arr[i];
        }
        return newArr;
    }
}

class Test01{
    /* 
    数组的扩容，无非就是创建一个新的数组 将元素赋值进去之后
    将新数组的地址返回即可
    */
    public static void main(String[] args){
        int[] arr=new int[]{1,2,3};
        arr=copyOf(arr,arr.length+1);
        arr[arr.length-1]=10;
        System.out.println(arr[3]);
    }
    public static int[] copyOf(int[] arr,int newLen){
        int[] newArr=new int[newLen];
        for(int i=0;i<arr.length;i++){
            newArr[i]=arr[i];
        }
        return newArr;
    }
}

来源：CSDN

作者：ADDCCff

链接：https://blog.csdn.net/ADDCCff/article/details/104348225

标签

string

判断素数

main函数

int函数

num