数组、方法练习题

1.求两个数的最大公约数和最小公倍数

import java.util.Scanner;

public class GongBS {
    public static void main(String[] args) {
        GongBeiShu();
    }
    //求最大公约数和最小公倍数
    public static void GongBeiShu(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数字：");
        int num1 = sc.nextInt();
        System.out.println("请输入第二个数字：");
        int num2 = sc.nextInt();
        //求最大公约数：从两个数中较小的一个开始找，到1结束
        int min = num1 < num2 ? num1 : num2;
        int gys = min;
        for (int i = num1; i <= 1; i++) {
            if(num1 % i == 0 && num2 % 1 == 0){
                gys = i;
                System.out.println("最大公约数是：" + gys);
                break;
            }

        }
        //求最小公倍数：从两个数较大一个开始找，到 num1 * num2结束
        int max = num1 > num2 ? num1 : num2;
        int gbs = max;
        for (int i = num1; i <= num1 * num2; i++) {
            if(i % num1 == 0 && i % num2 == 0){
                gbs = i;
                System.out.println("最小公倍数是：" + gbs);
                break;
            }
        }
    }
}

2.将《春晓》旋转90度输出

public class ChunXiao {
    public static void main(String[] args) {
        //定义一个二维数组
        char[][] arr = {
                {'春','眠','不','觉','晓'},
                {'处','处','闻','啼','鸟'},
                {'夜','来','风','雨','声'},
                {'花','落','知','多','少'}
        };
        round(arr);
    }
    //定义一个方法，翻转诗句
    public static void round(char[][] arr){
        for (int i = 0; i < arr.length + 1; i++) {
            for (int j = 3; j >= 0; j--) {
                System.out.print(arr[j][i] + " ");
            }
            System.out.println();
        }
    }
}

3.数组排序

import java.rmi.Naming;

public class Grand {
    public static void main(String[] args) {
        int[] scores = {44,78,99,87,89};
        sort(scores);
    }
    public static void sort(int[] arr){
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if(arr[j + 1] < arr[j]){
                   int temp = arr[j];
                   arr[j] = arr[j + 1];
                   arr[j + 1] = temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

4.判断回文数字

import java.util.Scanner;

public class HuiWen {
    public static void main(String[] args) {
        System.out.println(isHuiWen());
    }
    //判断回文数
    public static boolean isHuiWen(){
        //核心思路：将数字倒过来和原来的数字比较
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数字：");
        int number = sc.nextInt();
        //定义一个变量存放原来的数字
        int temp = number;
        //定义变量存放倒过来之后的数字
        int x = 0;
        while (number > 0){
            //每次获取最右边的数
            int ge = number % 10;
            //每次获取完之后修改number的值
            number = number / 10;
            //每次获取的数字拼接在最右边
            x = x * 10 + ge;
        }
        if(temp == x){
            return true;
        }else{
            return false;
        }
    }
}

5.给定一个整数数组，输入位置 n 和值 k。将值 k 插入到数组的第 n 位并输出新数组的每一个元素。

public class InsertKey {
    public static void main(String[] args) {
        //创建一个数组
        int[] arr = new int[]{3,44,38,5,47,15,38,47,5};
        //创建一个新数组
        int[] newArr = new int[arr.length + 1];
        int key = 100;
        int index = 6;
        insert(arr,newArr,key,index);
    }
    //定义方法：给定一个整数数组，输入位置 n 和值 k。将值 k 插入到数组的第 n 位并输出新数组的每一个元素。
    public static void insert(int[] arr,int[] newArr, int key, int index){
        //遍历新数组进行赋值
        for (int i = 0; i < newArr.length; i++) {
            if(i == index){
                newArr[i] = key;
            } else if (i < index) {
                //在index之前的原封不动拿过来
                newArr[i] = arr[i];
            }else {
                newArr[i] = arr[i - 1];
            }
        }
        for (int i = 0; i < newArr.length; i++) {
            System.out.print(newArr[i] + " ");
        }
    }
}

6.现有一个整数数组，数组中的每个元素都是[0-9]之间的数字，从数组的最大索引位置开始到最小索引位置， 依次表示整数的个位、十位、百位。。。依次类推。请编写程序计算，这个数组所表示的整数值。

import java.util.Random;
import java.util.Scanner;
// 现有一个整数数组，数组中的每个元素都是[0-9]之间的数字，从数组的最大索引位置开始到最小索引位置，
//        依次表示整数的个位、十位、百位。。。依次类推。请编写程序计算，这个数组所表示的整数值。
public class PinJie {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数字：");
        int n = sc.nextInt();
        //定义一个数组
        int[] arr = new int[n];
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = r.nextInt(10);
            System.out.print(arr[i] + " ");
        }
        System.out.println(ShuZu(arr));
    }
    //拼接数组
    public static int ShuZu(int[] arr){
        //定义拼接好之后的值
        int result = 0;
        for (int i = 0; i < arr.length; i++) {
            result = result * 10 + arr[i];
        }
        return result;
    }
}

7.给定一个整数数组，编写一个程序，移除数组中的重复元素，输出一个去重后的数组

public class ShuZuDistinct {
    public static void main(String[] args) {
        int[] arr = new int[]{3,44,38,5,47,15,38,47,5};
        //定义一个新数组
        int[] newArr = new int[arr.length];
        //定义新数组的下标
        int index = 0;
        distinct(arr,newArr,index);
    }
        //给定一个整数数组，编写一个程序，移除数组中的重复元素，输出一个去重后的数组
        //核心思路：新数组中的数据和原来数组中的数据比较，如果没有就放进去，有就不做任何操作
    public static void distinct(int[] arr,int[] newArr,int index){
        outer:for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < newArr.length; j++) {
                if(arr[i] == newArr[j]){
                    continue outer;
                }
            }
            //如果不存在直接到这里赋值
            newArr[i] = arr[i];
            index++;
        }
        for (int i = 0; i < index; i++) {
            System.out.print(newArr[i] + " ");
        }
    }
}

8.用递归实现阶乘

public class JiCheng {
    public static void main(String[] args) {
        System.out.println(factorial(5));
    }
    //用递归实现阶乘
    public static int factorial(int number){
        //递归的出口
        if(number == 1 || number == 0){
            return 1;
        }else {
            return number * factorial(number - 1);
        }
    }
}

9.用递归实现斐波那契数列

public class Feibo {
    public static void main(String[] args) {
        System.out.println(feibo(5));
    }

    //用递归实现斐波那契数列
    public static int feibo(int number){
        //递归的出口（递归一定要有出口，不然没办法停下来）
        if(number == 1 || number == 2){
            return 1;
        }else {
           return feibo(number - 1) + feibo(number - 2);
        }
    }
}

10.设计程序按照各个学生的 Java 成绩进行排序 ( 降序 )

public class ScoreSort {
//    设计程序按照各个学生的 Java 成绩进行排序 ( 降序 )
    public static void main(String[] args) {
        String[] names = { "安琪拉" , "王昭君" , "蔡文姬" , "妲己" , "张良" };
        // 设 courses 数组中依次存放三门课程的名称
        String[] courses = { "C++" , "Java" , "Python" };
        // 设 scores 数组中依次存储的是 names 数组中各个学生的 C++ 、Java 、Python 课程的成绩
        int[][] scores = {
                { 90 , 89 , 75 } ,
                { 59 , 40 , 100 } ,
                { 100 , 99 , 80 } ,
                { 80 , 61 , 61 } ,
                { 60 , 100 , 99 } ,
        };
        sortByJava(scores);
    }
    public static void sortByJava(int[][] arr){
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - 1; j++) {
                if(arr[j][1] < arr[j + 1][1]){
                    int[] arr1 = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = arr1;
                }
            }
        }
        for (int[] ints : arr) {
            for (int anInt : ints) {
                System.out.print(anInt + " ");
            }
            System.out.println();
        }
    }

}

11.随机排名

import java.util.Random;
import java.util.Scanner;

public class RandomGrand {
    public static void main(String[] args) {
        // 请先依次录入5名员工的工号，然后展示出一组随机的排名顺序
        Scanner sc = new Scanner(System.in);
        //创建数组
        int[] arr = new int[5];
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入第" + (i + 1) + "位员工的工号");
            arr[i] = sc.nextByte();
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        randomGrand(arr);
    }
    //随机排名
    //某公司开发部5名开发人员，要进行项目进展汇报演讲，现在采取随机排名后进行汇报。
    //把工号利用随机数打乱，生成随机数，把当前的工号与随机数字索引对应位置上的工号交换位置
    public static void randomGrand(int[] arr){
        //生成0-5的随机数，作为数组下标
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            //这里随机数范围不能写6，下标会越界，6就代表[0-5]，arr.length代表[0,4]
            int index = r.nextInt(arr.length);
            int temp = arr[i];
            arr[i] = arr[index];
            arr[index] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

12.打印杨辉三角

public class YangHui {
    public static void main(String[] args) {
        //打印杨辉三角形
        //先定义一个二维数组
        int[][] arr = new int[6][6];
        arr[0][0] = 1;
        arr[1][0] = 1;
        arr[1][1] = 1;
        for (int i = 2; i < arr.length; i++) {
            for (int j = 0; j < arr.length; j++) {
                if(j == 0 || j == i){
                    arr[i][j] = 1;
                }else {
                    arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
                }
            }
        }
        for (int[] t : arr) {
            for (int a : t) {
                if(a != 0){
                    System.out.print(a + "\t");
                }
            }
            System.out.println();
        }
    }
}

13.求二维数组最大值以及最大值的坐标

public class ErWeiMax {
    public static void main(String[] args) {
        int[][] arr = new int[][]{
                {1,3,2,5,8},
                {12,13,9,11,14},
                {9,16,17,8,5,3},
                {21,22,25,17,26},
                {13,15,17,11,8,9}
        };
        Max(arr);
    }
    //求二维数组最大值已经下标
    public static void Max(int[][] arr){
        //假设最大值
        int max = arr[0][0];
        int maxRow = 0;
        int maxCol = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length; j++) {
                if(arr[i][j] > max){
                    max = arr[i][j];
                    maxRow = i;
                    maxCol = j;
                }
            }
        }
        System.out.println("最大值是：" + max);
        System.out.println("最大值的坐标是：" + "[" + maxRow + "," + maxCol + "]");
    }
}

14.寻找完美数

import com.sun.source.doctree.SummaryTree;

import java.util.NavigableMap;

public class Ex09 {
    public static void main(String[] args) {
        //编写一个Java程序，使用循环输出所有的完美数。完美数是等于其所有因子之和的正整数，如 6 = 1 + 2 + 3
     perfect(10000);
    }
    public static void perfect(int limit){
        //limit表示上限
        //先找到1-limit之间的所有数字
        for (int num = 1; num <= limit; num++) {
           int sum = 0;
           //去找num的所有因子，也就是所有能整除它的数字
            for (int i = 1; i < num; i++) {
                if(num % i == 0){
                    sum += i;
                }
            }
            if(sum == num){
                System.out.println(num);
            }
        }

    }

}

15.写一个简单的登录系统 ，系统预先设置一个用户名和密码，用户最多有3次输入机会。 如果输入的用户名和密码与预设值匹配，则输出“登陆成功”，否则提示剩余尝试次数。

import java.util.ConcurrentModificationException;
import java.util.Scanner;
import java.util.TreeMap;

public class Ex08_1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int count = 3;
        while (true) {
            System.out.println("请输入用户名：");
            String name = sc.next();
            System.out.println("请输入密码：");
            String pass = sc.next();
            if (login(name,pass)){
                System.out.println("登录成功！");
                break;
            }else {
                count--;
                System.out.println("用户名或密码错误，请重新输入，你还有" + count + "次机会");
            }if(count == 0){
                System.out.println("你的账号已锁定");
                break;
            }
        }
    }

    public static boolean login(String name,String pass){
        String username = "kfm";
        String password = "123";
        return username.equals(name) && password.equals(pass);
    }
}