java习题集2

最新推荐文章于 2022-10-21 22:16:51 发布
最新推荐文章于 2022-10-21 22:16:51 发布
阅读量1.7k 收藏 16
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ADDCCff/article/details/104348225
版权

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;
    }
}

23、编写一个程序，读人 10 个数并且显示互不相同的数（即一个数出现多次，但仅显示一次）。（提示，读人一个数，如果它是一个新数，则将它存储在数组中。如果该数已经在数组中，则忽略它。）输入之后，数组包含的都是不同的数。下面是这个程序的运行示例：
在这里插入图片描述

import java.util.*;
public class A{
    public static void main(String[] args){
        /*
        1、
            在全部输入之后去重复 func1
        2、
            边输入边去重复 func2
        */
        // func1();
        func2();
    }
    public static void func2(){
        int[] arr=new int[0];
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter numbers:");
        for(int i=0;i<10;i++){
            int num=scanner.nextInt();
            if(!contains(arr,num)){
                arr=copyOf(arr,arr.length+1);
                arr[arr.length-1]=num;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    public static void func1(){
        //1.循环遍历数组进行赋值
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter numbers:");
        int[] arr = new int[10];
        for(int i = 0;i < arr.length;i++){
            arr[i] = scanner.nextInt();
        }
    }
    public static void method3(int[] arr){
        //不创建额外空间 不许改变原先的顺序
        int i=0;
        int size=arr.length;
        while(i<size){
            for(int j=i+1;j<size;){
                if(arr[j]==arr[i]){
                    for(int k=j+1;k<size;k++){
                        arr[k-1]=arr[k];
                    }
                    size--;
                }else{
                    j++;
                }
            }
            i++;
        }
        for(i=0;i<size;i++){
            System.out.print(arr[i]+" ");
        }
    }
    public static void method2(int[] arr){
        //插入排序
        for(int i=1;i<arr.length;i++){
            int e=arr[i];
            int j;
            for(j=i;j>0&&arr[j-1]>e;j--){
                arr[j]=arr[j-1];
            }
            arr[j]=e;
        }
        //连续相等
        for(int i=0;i<arr.length;){ //O(n)
            System.out.print(arr[i]+" ");
            int count=1;
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]==arr[i]){
                    count++;
                }else{
                    break;
                }
            }
            i+=count;
        }
    }
    public static void method1(int[] arr){
        int[] newArr=new int[0];
        for(int i=0;i<arr.length;i++){ //O(n)
            if(!contains(newArr,arr[i])){ //O(m)
                newArr=copyOf(newArr,newArr.length+1);
                newArr[newArr.length-1]=arr[i];
            }
        }
        System.out.println(Arrays.toString(newArr));
    }
    public static boolean contains(int[] arr,int key){
        for(int i=0;i<arr.length;i++){
            if(arr[i]==key){
                return true;
            }
        }
        return false;
    }
    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;
    }

}

24、编写以下方法，如果参数中的 list 数组已经按照升序排好了，则返回 true。
public static boolean isSorted(int[] list)编写一个测试程序，提示用户输人一个列表，显示该列表是否已经排好序。下面是一个行示例。注意，输人中的第一个数表示列表中的元素个数。该数不是列表的一部分。
在这里插入图片描述

import java.util.*;
public class A{
    public static void main(String[] args){
        //1.获取用户的输入 第一个输入的数据时数据的个数(数组的长度)
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter a list:");
        int len=scanner.nextInt();//获取的第一个数值就是数组的长度
        int[] arr=new int[len];
        for(int i=0;i<arr.length;i++){
            arr[i]=scanner.nextInt();
        }
        //2.对数组进行有序的判断
        if(isSorted(arr)){
            System.out.println("The list is already sorted.");
        }else{
            System.out.println("The list is not sorted.");
        }
    }
    public static boolean isSorted(int[] list){
        //如果不是升序排列 那会出现有一组数据 左大右小的情况
        for(int i=1;i<list.length;i++){
            if(list[i-1]>list[i]){
                return false;
            }
        }
        return true;
    }

}

25、(游戏：豆机）豆机，也称为梅花瓶或髙尔顿瓶，它是一个用来做统计实验的设备，是用英国科学家瑟弗兰克斯髙尔顿的名字来命名的。它是一个三角形状的均匀放置钉子（或钩子）的直立板子，如图所示。
在这里插入图片描述
球都是从板子口落下的。每当球碰到钉子，它就有 50%的机会落向左边或落向右边。在板子底部的槽子中都会累积一堆球。
编写程序模拟豆机。程序应该提示用户输入球的个数以及机器的槽数。打印每个球的路
径模拟它的下落。例如：在图b中球的路径是 LLRRLLR, 而在图 c中球的路径是RLRRLRR。使用条形图显示橹中球的最终储备量。下面是程序的一个运行示例
在这里插入图片描述

import java.util.*;
public class A{
    /*
    输入的数据：槽子的个数 球的个数=路径的个数
               创建槽子的具体的容器int[]
               每一个小球下落的路径L R 字符串
               对于每一个小球而言其路径中的步骤是随机产生L R
    1.提示用户输入槽子的个数和小球的个数
    2.根据已有的槽子的个数去创建槽子容器
    3.根据已有的球和槽子的个数去随机创建一个小球下落的路径
    4.路径中经过几个钉子？路径的步骤有几步 和槽子的个数有关
    5.如何通过路径的经过得知最终所落入的槽子？
    */
    public static void main(String[] args){
        //1.提示用户输入槽子的个数和小球的个数
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter the number of balls to drop:");
        int balls=scanner.nextInt();
        System.out.print("Enter the number of slots in the bean machine:");
        int slots=scanner.nextInt();
        //2.根据已有的槽子的个数去创建槽子容器
        int[] arr=new int[slots];
        //3.几个球几个路径path
        for(int i=0;i<balls;i++){
            String path=getPath(slots);
            System.out.println(path);
            //5.只要看当前路径中R的个数即可
            arr[getR(path)]++;
        }
        //6.输出
        System.out.println(Arrays.toString(arr));
        show(arr);
    }
    public static void show(int[] arr){
        int w=arr.length;
        int h=0;
        for(int i=0;i<arr.length;i++){
            if(arr[i]>h){
                h=arr[i];
            }
        }
        for(int i=h-1;i>=0;i--){
            for(int j=0;j<w;j++){
                if(i<arr[j]){
                    System.out.print("O");
                }else{
                    System.out.print(" ");
                }
            }
            System.out.println();
        }

    }
    public static int getR(String path){
        int count=0;
        for(int i=0;i<path.length();i++){
            if(path.charAt(i)=='R'){
                count++;
            }
        }
        return count;
    }
    public static String getPath(int slots){
        //4.根据槽子的个数计算每一个球下落的路径
        Random random=new Random();
        String path="";
        for(int j=0;j<slots-1;j++){
            if(random.nextInt(2)==0){   //向左
                path+="L";
            }else{  //向右
                path+="R";
            }
        }
        return path;
    }
}

26、如果两个数组 list 1和 list 2 的长度相同，而且对于每个i，list 1[i]都等于 list2[i], 那么认为 list 1和 list 2 是完全相同的。使用下面的方法头编写一个方法，如果 list 1和 list 2 完全相同，那么这个方法返回 true:
public static boolean equals(int[] list 1, int[] list 2)
编写一个测试程序，提示用户输人两个整数列表，然后显示这两个列表是否完全相同。下面是运行示例。注意，输人的第一个数字表明列表中元素的个数。该数字不是列表的一部分。
在这里插入图片描述

public class A{
    public static void main(String[] args){
        int[] list1={1,2,3,4,5,6,7};
        int[] list2={1,2,3,4,5,7,6};
        System.out.println(equals(list1,list2));
    }
    public static boolean equals(int[] list1,int[] list2){
        //判断两个数组是否完全相同
        //1.先判断长度
        if(list1.length!=list2.length){
            return false;
        }
        //2.再依次判断元素大小
        for(int i=0;i<list1.length;i++){
            if(list1[i]!=list2[i]){
                return false;
            }
        }
        return true;
    }
}

27、(模式识别方面：四个连续相等的数）编写下面的方法，测试某个数组是否有四个连续的值相同的数字。
public static boolean isConsecutiveFour(int[] values)
编写测试程序，提示用户输人一个整数列表，如果这个列表中有四个连续的具有相同值的数，那就显示 true ; 否则，显示 false。程序应该首先提示用户键人输人的大小，即列表中值的个数。这里是一个运行示例：
在这里插入图片描述

public class A{
    public static void main(String[] args){
        int[] arr={1,1,1,1,2,2,2,2,2,3,3,3,3,3,4};
        for(int i=0;i<arr.length;){
            int count=1;
            for(int j=i+1;j<arr.length;j++){
                if(arr[i]==arr[j]){
                    count++;
                }else{
                    break;
                }
            }
            if(count>=4){
                System.out.println(arr[i]);
                return;
            }
            i+=count;
        }
        System.out.println("没有！");
    }
}

28、编写下面的方法，将两个有序列表合并成一个新的有序列表。
public static int[] merge(int[] list1, int[] list2)
只进行list1.length+list2.length 次比较来实现该方法。编写一个测试程序，提示用户输入两个有序列表，然后显示合并的列表。下面是一个运行示例
在这里插入图片描述

import java.util.*;
public class A{
    public static void main(String[] args){
        int[] list1={1,3,5,7,9};
        int[] list2={2,4,6,8,10};
        System.out.println(Arrays.toString(merge(list1,list2)));
    }
    /*
    有序数组的合并
    最主要的问题在于 数组之间有长有短
    */
    public static int[] merge(int[] list1,int[] list2){
        if(list1==null&&list2==null){
            return null;
        }
        if(list1==null){
            return list2;
        }
        if(list2==null){
            return list1;
        }
        //只有两个都不是null的情况再考虑具体操作
        int[] list3=new int[list1.length+list2.length];
        int p1=0;
        int p2=0;
        int p3=0;
        while(true){
            if(p1==list1.length&&p2==list2.length){
                break;
            }
            if(p1<list1.length&&p2==list2.length){
                list3[p3++]=list1[p1++];
            }else if(p1==list1.length&&p2<list2.length){
                list3[p3++]=list2[p2++];
            }else{
                if(list1[p1]<=list2[p2]){
                    list3[p3++]=list1[p1++];
                }else{
                    list3[p3++]=list2[p2++];
                }
            }
        }
        return list3;
    }
}

29、编写一个猜宇游戏。随机产生一个单词，提示用户一次猜测一个宇母，如运
行示例所示。单词中的每个字母显示为一个星号。当用户猜测正确后，正确的字母显示出来。当用户猜出一个单词，显示猜错的次数，并且询问用户是否继续对另外一个单词进行游戏。声明一个数组来存储单词，如下所示：
在这里插入图片描述

import java.util.*;
public class A{
    /*
    数据 一组单词的明文  单词的密文  单词的状态
    program
    1000000 r r
    pr**r**
    */
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        Random random=new Random();
        //1.创建一个单词表
        String[] words={"naruto","kakashi","sasuke","banana","java","program"};
        //10.最后再去做多单词猜测
        while(true){
            //2.随机从单词表中抽取一个单词
            String word=words[random.nextInt(words.length)];
            //3.创建一个该单词的状态表 默认值是false(密文)
            boolean[] status=new boolean[word.length()];
            int miss=0; //猜错的个数
            //4.开始猜一个单词
            while(true){
                //5.根据单词和状态表 决定密文形式
                String ciphertext=getCipherText(word,status);
                //6.输出密文并提示用户输入字母
                System.out.print("Enter a letter in word "+ciphertext+" >");
                char letter=scanner.nextLine().charAt(0);//"p".charAt(0)
                //7.判断单词中是否有该字母
                if(isContainsLetter(word,letter)){
                    //8.改变单词状态表 已修改/未修改 
                    //true 表示从未修改 第一次来的
                    //false 表示已修改  不是第一次来 提示已经存在
                    if(!changeWordStatus(word,status,letter)){
                        System.out.println("\t "+letter+" is already in the word");
                    }
                }else{
                    System.out.println("\t "+letter+" is not in the word");
                    miss++;
                }
                //9.是否结束
                if(isFinish(status)){
                    System.out.println("The word is "+word+". You miss "+miss+" time");
                    break;
                }
            }
            System.out.print("Do you want to guess another word?Enter y or n:");
            String choice=scanner.nextLine();
            if(choice.equals("n")){
                System.out.println("Welcome!Thank you! FUCK PROGRAM!");
                break;
            }
        }
    }
    public static boolean isFinish(boolean[] status){
        for(int i=0;i<status.length;i++){
            if(!status[i]){
                return false;
            }
        }
        return true;
    }
    public static boolean changeWordStatus(String word,boolean[] status,char letter){
        for(int i=0;i<word.length();i++){
            if(word.charAt(i)==letter){
                if(status[i]){
                    return false;   //说明已经修改
                }else{
                    status[i]=true;
                }
            }
        }
        return true;
    }
    public static boolean isContainsLetter(String word,char letter){
        for(int i=0;i<word.length();i++){
            if(word.charAt(i)==letter){
                return true;
            }
        }
        return false;
    }
    public static String getCipherText(String word,boolean[] status){
        String ciphertext="";
        for(int i=0;i<status.length;i++){
            if(status[i]){
                ciphertext+=word.charAt(i);
            }else{
                ciphertext+="*";
            }
        }
        return ciphertext;
    }
}

30、编写一个方法，求整数矩阵中特定列的所有元素的和，使用下面的方
法头：
public static double sumColumn (double[] [] m , int columnlndex)
编写一个测试程序，读取一个 3 x 4 的矩阵，然后显示每列元素的和。下面是一个运行示例：
在这里插入图片描述

import java.util.*;
public class A{
    public static void main(String[] args){
        /*
            (0,0) (0,1) (0,2) (0,3)
            (1,0) (1,1) (1,2) (1,3)
            (2,0) (2,1) (2,2) (2,3)
            累加行的时候 行不动 列动
            累加列的时候 列不动 行动
        */
        //1.输入一个3*4的矩阵
        Scanner scanner=new Scanner(System.in);
        System.out.println("Enter numbers:");
        double[][] matrix=new double[3][4];
        for(int i=0;i<matrix.length;i++){
            for(int j=0;j<matrix[i].length;j++){
                matrix[i][j]=scanner.nextDouble();
            }
        }
        //2.打印每列的和
        for(int col=0;col<matrix[0].length;col++){
            System.out.println(sumColumn(matrix,col));
        }
    }
    public static double sumColumn(double[][] m,int col){
        double sum=0;
        for(int row=0;row<m.length;row++){
            sum+=m[row][col];
        }
        return sum;
    }
}

31、编写一个方法，求 nxn 的 double 类型矩阵中主对角线上所有数宇
的和，使用下面的方法头：
public static double sumMajorDiagonal (double[][] m)
编写一个测试程序，读取一个 4 x 4 的矩阵，然后显示它的主对角线上的所有元素的和。下面是一个运行示例：
在这里插入图片描述

public class A{
    public static void main(String[] args){
        /*
            (0,0) (0,1) (0,2) 
            (1,0) (1,1) (1,2) 
            (2,0) (2,1) (2,2)
            主对角线上的元素 行列角标是相等的
        */
        int[][] m={
            {1, 2, 3, 4},
            {5, 6, 7, 8},
            {9, 10,11,12},
            {13,14,15,16}
        };
        //主对角线
        int sum=0;
        for(int i=0;i<m.length;i++){
            sum+=m[i][i];
        }
        System.out.println(sum);
        //副对角线
        int subsum=0;
        for(int i=0;i<m.length;i++){
            subsum+=m[i][m.length-1-i];
        }
        System.out.println(subsum);
       
    }
}

32、编写两个矩阵相加的方法。方法头如下：
public static double[][] Matrix(double[][] a，double[][] b)
在这里插入图片描述

public class A{
    public static void main(String[] args){
        //m*n n*p m*p 矩阵相乘 前者的列 必须等于 后者的行
        /*
        1 2 3        1 2    1*1+2*3+3*5   1*2+2*4+3*6
                ×    3 4  = 
        4 5 6        5 6    4*1+5*3+6*5   4*2+5*4+6*6
        对于数学上的一些运算公式 如果直接通过看计算流程还是比较麻烦的
        此时推荐使用已知公式计算！
        */
        double[][] A={ //m*p
            {1,2,3},
            {4,5,6},
            {7,8,9}
        };
        double[][] B={ //p*n
            {0,2.0,4.0},
            {1,4.5,2.2},
            {1.1,4.3,5.2}
        };
        double[][] C=new double[A.length][B[0].length];//m*n
        for(int i=0;i<C.length;i++){
            for(int j=0;j<C[i].length;j++){
                double sum=0;
                for(int k=0;k<B.length;k++){
                    sum+=A[i][k]*B[k][j];
                }
                C[i][j]=sum;
                System.out.print(C[i][j]+"　");
            }
            System.out.println();
        }
    }
}

33、编写程序，提示用户输入一个方阵的长度，随机地在矩阵中填人 0 和1, 打印这个
矩阵，然后找出整行、整列或者对角线都是 0 或1的行、列和对角线。下面是这个程序的一个运行示例：
在这里插入图片描述

import java.util.*;
public class A{
    public static void main(String[] args){
        //1.输入方针的尺寸 创建方阵
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter size:");
        int size=scanner.nextInt();
        int[][] m=new int[size][size];
        //2.随机的给方阵中填入0或1
        Random random=new Random();
        for(int i=0;i<size;i++){
            for(int j=0;j<size;j++){
                m[i][j]=random.nextInt(2);
                System.out.print(m[i][j]+" ");
            }
            System.out.println();
        }
        //3.让行，列，对角线累加 sum==0 sum==size 表示全相等
        checkRow(m);
        checkCol(m);
        checkDiagonal(m);
        checkSubDiagonal(m);
    }
    public static void checkSubDiagonal(int[][] m){
        int sum=0;
        for(int i=0;i<m.length;i++){
            sum+=m[i][m.length-1-i];
        }
        if(sum==m.length||sum==0){
            System.out.printf("副主对角线全相等且是%d\n",sum==0?0:1);
        }
    }
    public static void checkDiagonal(int[][] m){
        int sum=0;
        for(int i=0;i<m.length;i++){
            sum+=m[i][i];
        }
        if(sum==m.length||sum==0){
            System.out.printf("主对角线全相等且是%d\n",sum==0?0:1);
        }
    }
    public static void checkRow(int[][] m){
        for(int i=0;i<m.length;i++){
            int sum=0;
            for(int j=0;j<m[i].length;j++){
                sum+=m[i][j];
            }
            if(sum==m.length||sum==0){
                System.out.printf("第%d行全相等且是%d\n",i+1,sum==0?0:1);
            }
        }
    }
    public static void checkCol(int[][] m){
        for(int j=0;j<m.length;j++){
            int sum=0;
            for(int i=0;i<m.length;i++){
                sum+=m[i][j];
            }
            if(sum==m.length||sum==0){
                System.out.printf("第%d列全相等且是%d\n",j+1,sum==0?0:1);
            }
        }
    }
}

34、编写下面的方法. 测试一个二维数组是否有四个连续的数宇具有相同的值，这四个数可以是水平方向的、垂直方向的或者对角线方向的。
public static boolean isConsecutiveFour(int[][] values)
编写一个测试程序，提示用户输人一个二维数组的行数、列数以及数组中的值。如果这个
数组有四个连续的数宇具有相同的值，就显示 true ; 否则，显示 false。下面是结果为 true 的一些例子：
在这里插入图片描述

import java.util.*;
public class A{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter row ,col:");
        int row=scanner.nextInt();
        int col=scanner.nextInt();
        int[][] m=new int[row][col];
        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                m[i][j]=scanner.nextInt();
            }
        }
        System.out.println(isConsecutiveFour(m));
    }
    public static boolean isConsecutiveFour(int[][] m){
        for(int i=0;i<m.length;i++){
            for(int j=0;j<m[i].length;j++){
                //向右
                if(j<=m[i].length-4){
                    boolean flag=true;
                    for(int c=j+1;c<=j+3;c++){
                        if(m[i][j]!=m[i][c]){
                            flag=false;
                            break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                }
                //向下
                if(i<=m.length-4){
                    boolean flag=true;
                    for(int r=i+1;r<=i+3;r++){
                        if(m[i][j]!=m[r][j]){
                            flag=false;
                            break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                }
                //向右下
                if(i<=m.length-4&&j<=m[0].length-4){
                    boolean flag=true;
                    for(int r=i+1,c=j+1;r<=i+3;r++,c++){
                        if(m[i][j]!=m[r][c]){
                            flag=false;
                            break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                }
                //向右上
                if(i>=3&&j<=m[0].length-4){
                    boolean flag=true;
                    for(int r=i-1,c=j+1;c<=j+3;r--,c++){
                        if(m[i][j]!=m[r][c]){
                            flag=false;
                            break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                }
            }
        }
        return false;//四个方向都没有连续的
    }
}

35、拉丁正方形是一个 nXn 的数组，由 1« 个不同的拉丁字母填充，每个拉丁字母恰好
只在每行和每列中出现一次。编写一个程序，提示用户输人数字 n 以及字符数组，如示例输出所示，检测该输出数组是否是一个拉丁正方形。字符是从 A 开始的前面 n 个字符。
在这里插入图片描述

public class A {
 
    public static void main(String args[]) {
        int size=9;
        Node node= createLink(size);
        printLatin(node,size);
    }
 
    private static void printLatin(Node node,int size){
        Node head=node;
        for (int i = 1; i <=size; i++) {
            Node temp=head.next;
            for (int j=1;j<=size;j++){
                System.out.print(temp.getData());
                temp=temp.next;
            }
            System.out.println();
            head=head.next;
        }
    }
    private static Node createLink(int size){
        Node head=new Node();
        Node temp=head;
        for (int i=1;i<=size;i++){
            Node node=new Node(i);
            temp.setNext(node);
            temp=node;
        }
        temp.next=head.next;
        return head;
    }
    static class Node{
 
        private int data;
        private Node next;
 
        public Node(){}
        public Node(int data){
            this.data=data;
        }
 
        public int getData() {
            return data;
        }
 
        public void setData(final int data) {
            this.data = data;
        }
 
        public Node getNext() {
            return next;
        }
 
        public void setNext(final Node next) {
            this.next = next;
        }
    }
}

36、五子棋问题

import java.util.*;
public class A{
    /* 
    
    +++++++
    +++++++
    +++++++
    需要创建一个String的二维数组来表示棋盘
    如何下棋呢？
   
    输入 1,1 指的就是在(0,0)处下一个棋子
    
    初始化棋盘 initBoard()
    打印棋盘   printBoard()
    开始游戏   startGame()
    下棋(黑白) putDownChess()
    判断输赢   isGameOver()
    上述方法都会去调用棋盘board数据 
    如果每次讲board当做参数传递个函数的时候 会显得比较麻烦
    我们可以将board数据定义为全局变量 任何函数都可以访问的变量
    全局变量定义在函数的外面 类的里面 必须public static开头
    */

    //全局变量 棋盘 方便函数直接调用 而不需要依次传参
    public static String[][] board; //定义为是15*15的棋盘
    public static String BLACK_CHESS="O";   //黑棋
    public static String WHITE_CHESS="X";   //白棋
    public static Scanner scanner=new Scanner(System.in);

    public static void main(String[] args){
        //1.初始化棋盘
        initBoard();
        //2.打印棋盘
        printBoard();
        //3.开始游戏
        startGame();
    }
    public static void startGame(){
        /*
        黑方 白方 轮流 下棋 
        */
        int player=0;   //player 偶数 黑 ；奇数 白
        while(true){
            if(player%2==0){    //黑方下棋
                System.out.print(">>>请黑方下棋:");
                if(!putDownChess(BLACK_CHESS)){
                    continue;
                }
            }else{              //白方下棋
                System.out.print(">>>请白方下棋:");
                if(!putDownChess(WHITE_CHESS)){
                    continue;
                }
            }
            if(isGameOver()){
                break;
            }
            player++;
        }
    }
    public static boolean isGameOver(){
        //你们自己写吧 我写过了 注意和棋的情况
        return false;
    }
    public static boolean putDownChess(String chess){
        //用户输入的 (1,1) -> (0,0)
        //1 B
        int x=scanner.nextInt()-1;
        int y=scanner.next().charAt(0)-'A';
        if(!board[x][y].equals("+")){
            System.out.println(">>>此处已有棋子，请重新下棋");
            //另外一种处理方式 就是讲player定义为全局 此处player--即可
            return false;//意味着下棋不成功
        }
        board[x][y]=chess;
        printBoard();
        return true;    //意味着下棋成功
    }
    public static void printBoard(){
        System.out.print("   ");
        for(int i=0;i<=14;i++){
            System.out.print((char)('A'+i)+" ");
        }
        System.out.println();
        for(int i=0;i<board.length;i++){
            System.out.printf("%2d ",i+1);
            for(int j=0;j<board[i].length;j++){
               System.out.print(board[i][j]+" ");
            }
            System.out.println();
        }
    }
    public static void initBoard(){
        board=new String[15][15];
        for(int i=0;i<board.length;i++){
            for(int j=0;j<board[i].length;j++){
                board[i][j]="+";
            }
        }
    }
}
ADDCCff
关注
Java、最大值出现次数
m0_62659797的博客
01-31 1423
编写程序读取整数，找出它们的最大数，然后计算该数的出现次数。假设输入是以 0 结束的。假定输入是 3 5 2 5 5 5 0，程序找出最大数 5，而 5 的出现次数是 4。 提示：维护max 和 count 两个变量。max 存储当前最大数，而 count 存储它的出现次数。初始状态时，将第一个数赋值给max 而将 count 赋值为 1。然后将接下来的每个数字逐个的和 max 比较。如果这个数大于 max，就将它赋值给 max，同时将 count 重置为 1。如果这个数等...
编写程序读取整数，找出它们中的最大值，然后计算它的出现次数。假设输入以数字“0“结束
weixin_69075299的博客
04-03 3221
max = 0 count = 0 while True: n = eval(input"请输入一个数值:") if n == 0: print("输入结束!") break elif n > max: max = n count = 1 elif n == max: count += 1 print("最大值是{}，出现了{}次".format(max,count)...
【PTA】统计最大数出现次数
qq_63806300的博客
10-21 442
编写程序读取一系列整数，找出它们的最大数，然后计算该数的出现次数，假定输入以0结束。
Java 二维数组矩阵特定列的和
m0_52744886的博客
11-13 1551
编写一个方法，求整数矩阵中特定列的所有元素的和，使用下面的方法头: public static double sumColumn(double[][] m, int columnlndex) 编写一个测试程序，读取一个3 x 4的矩阵，然后显示每列元素的和。 package com; import java.util.Scanner; class Demo1_4{ public static void main(String[] args){ // TODO Auto-generated
Java编程练习题Demo81-Demo95
weixin_51612062的博客
08-16 832
Java编程练习题Demo81-Demo95，涉及函数、数组、二维数组等知识，超级详细！每天刷一刷！
JAVA习题集2.doc
06-28
### JAVA习题集2知识点解析 #### 一、判断题解析 1. **一个类定义了一个或多个构造方法，那么 Java 不提供默认的构造方法。** 正确。当一个类至少定义了一个构造方法时（无论是无参还是有参），Java 编译器将...
JAVA习题集2.pdf
09-13
JAVA习题集2.pdf 该资源文件是一个 Java 编程语言的习题集，涵盖了 Java 语言的基础知识点，包括类和对象、构造方法、变量、方法、访问控制符、构造方法、静态成员域、类成员变量、方法调用、构造方法特点、对象的...
java习题集，java练习习题集，java面试习题集
最新发布
08-28
java习题集，java练习习题集，java面试习题集
Java基础知识（数组）
weixin_45777287的博客
11-14 717
数组的概念： 数组使同一种类型数据的集合；即能够存放多个相同类型的数据的容器。 数组的定义方式 数组是存放多个数据的容器，Java中需要使用new关键字来创建容器，在创建容器时也要明确容器的大小，即容器中存放数据个数。 元素类型[] 数组名 = new 元素类型[元素个数或数组长度]; int[] arr=new int[3];//通过new关键字创建了一个长度为3，元素类型是int的数组实体。 ...
Java，第二次作业——最大数的出现次数
weixin_52572455的博客
04-17 1913
题目： （最大数的出现次数）编写程序读取整数，找出它们的最大数，然后计算该数的出现次 数。假设输入是以 0 结束的。假定输入是 3 5 2 5 5 5 0， 程序找出最大数 5， 而 5 出现的 次数是 4。 提示：维护 max 和 count 两个变量。 max 存储当前最大数，而 count 存储它的出现次数。 初始状态时，将第一个数赋值给 max 而将 count 赋值为 1。然后将接下来的每个数字逐 个地和 max 进行比较。如果这个数大于 max， 就将它赋值给 max， 同时将 count 重罝
Java编程练习题Demo71-Demo80
weixin_51612062的博客
07-30 765
Java编程练习题：Demo71-Demo80，每天刷几道！
2021 JAVA期末复习（编程题）1
qq_53958979的博客
12-21 2603
学校期末考试自用，没啥含金量
《数据结构》-复杂度
WeiMengXS的博客
11-12 264
时间复杂度_空间复杂度 1.算法效率 2.时间复杂度 3.空间复杂度 1.算法效率 算法效率分析分为两种：第一种是时间效率，第二种是空间效率。时间效率被称为时间复杂度，而空间效率 被称作空间复杂度。 时间复杂度主要衡量的是一个算法的运行速度，而空间复杂度主要衡量一个算法所需要 的额外空间，在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机 行业的迅速发展，计算机的存...
二维数组
qq_37244548的博客
02-26 807
1，编写一个方法，求整数矩阵中特定列的所有元素的和，使用下面的方法头 public static double sumColumn(double [][] m,int columnIndex){ 编写一个测试的程序,读取一个3*4的矩阵,然后显示每列元素的和 思路：1，求列的元素和，就是列不变，行改变 2，求行元素的和,就是行不变，列改变 class test59{ public stat...
利用Random类来产生5个20~50之间的随机整数
热门推荐
:)一位靓仔偶然路过的博客
09-30 3万+
14、利用Random类来产生5个20~50之间的随机整数。  提示：[n-m](n、m均为整数，n import java.util.Random; public class Test03 { public static void main(String[] args) { Random rand = new Random(); int[] num = n
3.13编写程序，提示用户输入一个十进制整数，然后显示对应的二进制值。在这个程序中不要使用Integer.toBinaryString(int)
liuwenqing11的博客
09-30 2048
1. 题目要求 编写程序，提示用户输入一个十进制整数，然后显示对应的二进制值。在这个程序中不要使用Integer.toBinaryString(int) 比如说 16 对应的二进制为 1000 int 特点 输出整数 17除2 等于 8 2.编写输出 2进制 3.0结果图 4.输出正确 10进制转2进制是自下向上的 所以我们倒序一下 利用字符串数组 结果图 5.0 全部代码 package booksTest; impo.
求矩阵主对角线元素的和
weixin_45646245的博客
10-07 8639
编写一个方法，求 nxn 的 double 类型矩阵中主对角线上所有数宇 的和，使用下面的方法头： public static double sumMajorDiagonal (double[][] m) 编写一个测试程序，读取一个矩阵，然后显示它的主对角线上的所有元素的和。 代码如下： import java.util.Scanner; public class SumMajorDiagonal...
第八章第二题（求矩阵主对角线元素的和）（Finding the sum of the main diagonal elements of a matrix）
jxh1025_的博客
10-29 2492
第八章第二题（求矩阵主对角线元素的和）（Finding the sum of the main diagonal elements of a matrix） *8.2（求矩阵主对角线元素的和）使用下面的方法头编写一个方法，求nxn的double类型矩阵中主对角线上所有数字的和： public static double sumMajorDiagonal(double[][] m) 编写一个测试程序，读取一个4x4的矩阵，然后显示他的主对角线上的所有元素的和。下面是一个运行示例： Enter a 4-by-
Java习题集详解及答案大全
Java习题集是一套针对Java程序设计的教材，由李新良编著，旨在帮助电子信息工程系软件教研室的学生深化理解和实践Java语言。该习题集包含了丰富的练习题目和解答，适合于教学或个人学习中进行自我测试与提升。 第一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值