《Java练习题》Java习题集四

编程合集： https://www.cnblogs.com/jssj/p/12002760.html

Java总结：https://www.cnblogs.com/jssj/p/11146205.html

【程序31】
题目：取一个整数a从右端开始的4～7位。

import java.util.Scanner;

/**
 * 【程序31】
 * 题目：取一个整数a从右端开始的4～7位。
 */
public class Subject31 {
    public static void main(String[] args) {
        Scanner scanner =new Scanner(System.in);
        System.out.println("请输入一个操作8位的整数");
        String num = scanner.next();
        intercept(num);
    }

    /**
     * 截取num
     * @param num
     */
    private static void intercept(String num) {
        char[] arr = num.toCharArray();
        int j=0;
        System.out.print("截取结果为：");
        for(int i = arr.length-1 ; i >= 0;i--){
            j++;
            if(j >= 4 && j<=7){
                System.out.print(arr[i]+" ");
            }
        }
    }
}

运行结果：

 

【程序32】
题目：打印出杨辉三角形（要求打印出10行如下图） ,完美杨辉三角。

import java.util.ArrayList;
import java.util.List;

/**
 * 【程序32】
 * 题目：打印出杨辉三角形（要求打印出10行如下图）
 */
public class Subject32 {

    private static int num_1 = 10;
    private static List<int[]> list = new ArrayList<>();

    public static void main(String[] args) {
        System.out.println("杨辉三角形打印如下：");
        yangHuiTriangle(num_1);
        int maxLength = (list.get(list.size()-1)[num_1/2]+"").length();
        boolean flag = isParity(maxLength);
        for (int i = 0 ; i < list.size(); i++) {
            int[] arr = list.get(i);
            printSpace(arr,maxLength);
            for (int j = 0; j < arr.length; j++) {
                System.out.print(arr[j]);
                int tmp = (arr[j]+"").length();
                if(flag){
                    for (int k = 0; k < maxLength+2 - tmp; k++) {
                        System.out.print(" ");
                    }
                }else{
                    for (int k = 0; k < maxLength+1 - tmp; k++) {
                        System.out.print(" ");
                    }
                }

            }
            System.out.println();
        }
    }

    /**
     * 判断maxLength是奇数还是偶数
     * @param maxLength
     * @return
     */
    private static boolean isParity(int maxLength) {
        if(maxLength%2 == 1){
            return false;
        }else {
            return true;
        }
    }

    /**
     * 获取杨辉三角数据
     * @param num
     * @return
     */
    private static int[] yangHuiTriangle(int num) {
        if(num == 1){
            int[] arr = new int[]{1};
            list.add(arr);
            return arr;
        }else{
            int[] arrPro = yangHuiTriangle(num-1);
            int[] arrAft = new int[num];
            for (int i = 0; i < arrAft.length ; i++) {
                if(i == 0){
                    arrAft[i] = 0+arrPro[i];
                }else if( i== arrAft.length-1){
                    arrAft[i] = arrPro[i-1]+0;
                }else{
                    arrAft[i] = arrPro[i-1] + arrPro[i];
                }
            }
            list.add(arrAft);
            return arrAft;
        }
    }

    /**
     * 空格打印
     * @param arr
     */
    private static void printSpace(int[] arr,int maxLength) {
        for (int i = 0; i < num_1 - arr.length ; i++) {
            double loopNum = Math.ceil((maxLength+1)/2.0);
            for (int j = 0; j < loopNum; j++) {
                System.out.print(" ");
            }
        }
    }
}

运行结果：

【程序33】
题目：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。

/**
 * 【程序33】
 * 题目：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。
 */
public class Subject33 {

    public static void main(String[] args) {
        int[] arr = new int[]{44,56,89,32,11,78,55,82,02,68,44,27};
        printArray(arr);
        deal(arr);
    }

    private static void deal(int[] arr) {
        int maxNum = arr[0];    //最大数
        int minNum = arr[0];    //最小数
        int maxPosition = 0;    //最大数在数组的位置。
        int minPosition = 0;    //最小数在数组的位置。
        for (int i = 1; i <  arr.length; i++) {
            if(arr[i] > maxNum){
                maxNum = arr[i];
                maxPosition = i;
            }
            if(arr[i] < minNum){
                minNum = arr[i];
                minPosition = i;
            }
        }

        /*********重组数组（最大的与第一个元素交换，最小的与最后一个元素）************/
        int tmp = 0;
        tmp = arr[0];
        arr[0] = arr[maxPosition];
        arr[maxPosition] = tmp;

        tmp = arr[arr.length-1];
        arr[arr.length-1] = arr[minPosition];
        arr[minPosition] = tmp;

        /*********打印数组***********/
        printArray(arr);
    }

    /**
     * 打印数组
     * @param arr
     */
    private static void printArray(int[] arr) {
        for (int i = 0; i < arr.length ; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
}

运行结果：

【程序34】
题目：有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数

/**
 * 【程序34】
 * 题目：有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数
 */
public class Subject34 {

    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
        /**********************打印数组*************************/
        printArray(arr);
        int m = 6;   //偏移量
        deviation(arr,m);
    }

    /**
     * 数组arr偏移m后的结果
     * @param arr
     * @param m
     */
    private static void deviation(int[] arr,int m) {
        int[] newArr = new int[m];
        int count = m-1;
        /*******************将最后m为数保存到新数组中********************/
        for (int i = arr.length-1; i >= arr.length-m ; i--) {
            newArr[count--] = arr[i];
        }

        /********************将数组中的数据往后移动m位***************************/
        for (int i =  arr.length-1; i >= m; i--) {
            arr[i] = arr[i-m];
        }

        /**********************数组前面的数据补充完整*************************/
        for (int i = 0; i < newArr.length; i++) {
            arr[i] = newArr[i];
        }

        /**********************打印数组*************************/
        printArray(arr);
    }

    /**
     * 打印数组
     * @param arr
     */
    private static void printArray(int[] arr) {
        for (int i = 0; i < arr.length ; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
}

运行结果：

【程序35】
题目：有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * 【程序35】
 * 题目：有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位
 */
public class Subject35 {
    public static void main(String[] args) {
        System.out.println("请输入人数：");
        Scanner scanner = new Scanner(System.in);
        int n= scanner.nextInt();
        numberGame(n);
    }

    /**
     * 数字游戏
     * @param n
     */
    private static void numberGame(int n) {
        List<Integer> list = new ArrayList<>();
        /****************给50个人编号******************/
        for (int i = 1; i <= n; i++) {
            list.add(i);
        }
        endGameByNum(list,1);
    }

    /**
     * 获取最后留下的人
     * @param list
     * @param ident
     */
    private static void endGameByNum(List<Integer> list,int ident) {
        List<Integer> listTmp = new ArrayList<>();

        if(list.size() >=  3 ) {
            for (int i = 0; i < list.size(); i++) {
                if ((i+ident)%3 != 0) {
                    listTmp.add(list.get(i));
                }
            }
            endGameByNum(listTmp,list.size()%3+1);
        }else{
            for (int i = 0; i < list.size(); i++) {
                System.out.println("最后留下的人为"+list.get(i)+"号选手！");
            }
        }
    }
}

运行结果：

 

【程序36】
题目：写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。

import java.util.Scanner;

/**
 * 【程序36】
 * 题目：写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。
 */
public class Subject36 {

    public static void main(String[] args) {
        System.out.println("请输入一个字符串：");
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        stringLength(str);
    }

    /**
     * 输出字符串长度
     * @param str
     */
    private static void stringLength(String str) {
        char[] arr = str.toCharArray();
        System.out.println("字符串长度："+ arr.length);
    }
}

运行结果：

【程序37】
题目：编写一个函数，输入n为偶数时，调用函数求1/2+1/4+…+1/n,当输入n为奇数时，调用函数1/1+1/3+…+1/n

import java.util.Scanner;

/**
 * 【程序37】
 * 题目：编写一个函数，输入n为偶数时，调用函数求1/2+1/4+…+1/n,当输入n为奇数时，调用函数1/1+1/3+…+1/n
 */
public class Subject37 {

    private static double sum = 0;    //求和

    private static String str = "";   //拼接字符串

    public static void main(String[] args) {
        System.out.println("请输入一个正整数：");
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        specialDeal(num);
        System.out.print(str.substring(0,str.length()-2)+"的和为：");
        System.out.println(sum);
    }

    /**
     * 输入n为偶数时，调用函数求1/2+1/4+…+1/n,当输入n为奇数时，调用函数1/1+1/3+…+1/n
     * @param num
     */
    private static void specialDeal(int num) {
        sum = sum+ 1.0/num;
        if(num > 2){
            specialDeal(num-2);
        }
        str = str+"1/"+num+" + ";
    }
}

运行结果：

【程序38】
题目：字符串排序。

/**
 * 【程序38】
 * 题目：字符串排序。
 */
public class Subject38 {
    public static void main(String[] args) {
        String[] arrStr = new String[]{"asd","bbb","dddd","add","eddd","ccdd","caaa","adds","cvf","dass"};
        System.out.print("初始数组：");
        printStrinArray(arrStr);
        stringOrder(arrStr);
    }

    /**
     * 字符串数组排序
     * @param arrStr
     */
    private static void stringOrder(String[] arrStr) {
        for (int i = 0; i <arrStr.length ; i++) {
            for (int j = i+1; j < arrStr.length; j++) {
                String tmp = "";
                if(arrStr[i].compareTo(arrStr[j]) > 0){
                    tmp = arrStr[i];
                    arrStr[i] =  arrStr[j];
                    arrStr[j] = tmp;
                }
            }
        }
        System.out.print("排序后数组：");
        printStrinArray(arrStr);
    }

    /**
     * 字符串数组打印
     * @param arrStr
     */
    private static void printStrinArray(String[] arrStr) {
        for (int i = 0; i < arrStr.length; i++) {
            System.out.print(arrStr[i]+" ");
        }
        System.out.println();
    }
}

运行结果：

【程序39】
题目：海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子凭据分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？

/**
 * 【程序39】
 * 题目：海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子凭据分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。
 * 第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的，
 * 问海滩上原来最少有多少个桃子？
 */
public class Subject39 {

    private static int count = 0;  //分桃次数
    private static int tmp = 0;    //桃子数量

    public static void main(String[] args) {
        averagePeachTot();
    }

    /**
     * 循环获取桃子总数
     */
    private static void averagePeachTot() {
        int frequency = 4;
        while(true){
            if(count == 6){
                System.out.println(tmp);
                break;
            }
            count =0;
            averagePeach(frequency);
            frequency+=4;
        }
    }

    /**
     * 平分桃子
     */
    private static void averagePeach(int num) {
        count++;
        if(num%4 == 0 && count<=5){
            tmp = num + 1 + num/4;
            averagePeach( tmp);
        }
    }
}

运行结果：

【程序40】
题目：809*??=800*??+9*??+1
其中??代表的两位数,8*??的结果为两位数，9*??的结果为3位数。求??代表的两位数，及809*??后的结果

/**
 * 【程序40】
 * 题目：809*??=800*??+9*??+1    改成 809*??=800*??+9*??
 * 其中??代表的两位数,8*??的结果为两位数，9*??的结果为3位数。求??代表的两位数，及809*??后的结果, 题目错误
 */
public class Subject40 {
    public static void main(String[] args) {
        mathematicsFormula();
    }

    /**
     * 数学公式
     */
    private static void mathematicsFormula() {
        boolean flag = false;
        for (int i = 10; i < 100 ; i++) {
            if( 8*i < 100 && 9*i >100 && 809*i == 800*i+9*i){
                flag = true;
                System.out.println("??=" + i);
                System.out.println("809*?? = " + 809*i);
            }
        }
        if(!flag){
            System.out.println("为找到合适的数");
        }
    }
}

运行结果：

参考：https://blog.csdn.net/zzzzzzzhu/article/details/82355001