黑马程序员--JAVA<四题经典编程题>--

——- android培训、java培训、期待与您交流！ ———-

---

第一题： 将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。

import java.util.ArrayList;

/*
 * 需求： 将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。
 * 思路：1.定义一个方法，方法的作用是为一个数从1开始到其本身之间求模
 *          模为0的则这个数是其质因数
 *      2.当模为0时，继续调用此方法，传入商的值。
 *      3.当全部不能整除时，剩下的就是其质因数。
 */
public class Test04 {

    public static void main(String[] args) {
        // 求555555的质因数
        new GetZhiYinShu(555555);
    }
}

class GetZhiYinShu {
    // 需要求质因数的正整数。
    private int number;
    // 用于存储质因数。
    private ArrayList<Integer> al = new ArrayList<Integer>();

    public GetZhiYinShu(int number) {
        super();
        this.number = number;
        getNumber(number);
        show();
    }

    /**
     * 这是一个获取质因数集合的方法，方便外界获取
     * 
     * @return 质因数集合
     */
    public ArrayList<Integer> getAl() {
        return al;
    }

    /**
     * 这是一个获取质因数的方法
     * 
     * @param number
     *            需要求质因数的正整数
     */
    public void getNumber(int number) {
        for (int i = 2; i <= number; i++) {
            if (number % i == 0) {
                getNumber(number / i);
                al.add(i);
                break;
            }
        }
    }

    /**
     * 这是一个在控制台打印质因数的方法
     */
    public void show() {
        StringBuffer sb = new StringBuffer();
        for (int i = al.size() - 1; i >= 0; i--) {
            if (i != 0)
                sb.append(al.get(i) + "*");
            else
                sb.append(al.get(i));
        }
        System.out.println(number + "=" + new String(sb));
    }
}

---

第二题：输入两个正整数m和n，求其最大公约数和最小公倍数。

import java.util.Arrays;

/*
 * 需求：输入两个正整数m和n，求其最大公约数和最小公倍数。   
 * 思路：1.定义一个方法，方法接收一个int类型的整数m，n，返回一数组
 *          从2~n找出m和n都能整除的数
 *          第一次找到后，重新调用此方法，传入m、n除以这个数的商
 *          把这个数加到数组中并跳出此循环
 *          返回此数组
 *      2.调用定义的方法，传入m和n。所得的数组为他们的公约数，最大值为最大公约数
 *      3.用m分别除以数组的每个元素，得的商再乘以n，得的值就是他们的最小公倍数。
 * */
public class Test06 {
    public static void main(String[] args) {
        new GetTest06(55, 77);
    }
}

class GetTest06 {
    // 定义数组，存储公约数。初始长度为20.
    int[] arr = new int[20];
    // 计数器
    int count = 0;
    // 需要求公约数和公倍数的两个整数。
    int m, n;

    public GetTest06(int m, int n) {
        super();
        this.m = m;
        this.n = n;
        getNum(m, n);
        getGongYueShu();
        getGongBerShu();
    }

    /**
     * 这是一个求两个数的公约数的方法，所得的公约数存入数组中。
     * 
     * @param m
     *            第一个正整数
     * @param n
     *            第二个正整数
     */
    public void getNum(int m, int n) {
        for (int i = 2; i < m; i++) {
            if (m % i == 0 && n % i == 0) {
                getNum(m / i, n / i);
                arr[count++] = i;
                break;
            }
        }
    }

    /**
     * 这是一个根据所得的公约数数组求最大公约数的方法
     */
    public void getGongYueShu() {
        Arrays.sort(arr);
        System.out.println("最大公约数：" + arr[arr.length - 1]);
    }

    /**
     * 这是一个根据所得的公约数数组求最小公倍数的方法
     */
    public void getGongBerShu() {
        for (int i : arr) {
            if (i != 0) {
                m /= i;
            }
        }
        System.out.println("最小公倍数：" + m * n);
    }
}

---

第三题：判断101-200之间有多少个素数，并输出所有素数。

/*
 * 需求：判断101-200之间有多少个素数，并输出所有素数。
 */
public class Test02 {
    public static void main(String[] args) {
        test02();
    }

    public static void test02() {
        int number = 100000000;
        int[] nums = new int[number / 10000];
        nums[0] = 2;
        int count = 0;
        // int count2 = 0;

        for (int i = 1; i <= number; i++) {
            nums = findNumber(nums, i);
            // nums2 = getNums(nums2,i);
        }

        for (int i : nums) {
            if (i == 0)
                break;
            if (i > 1) {
                count++;
                System.out.print("_" + i);
            }
        }
        System.out.println("一共有：" + count + "个素数");
    }

    /*
     * 思路：找到2~101间的素数，再把101~200间的数分别与这些素数求模， 模为0的不是素数。 2~101间素数的思路：从2开始，
     * 分别除在它之前的素数，能整除则非素数
     */
    static int[] getNums(int[] nums, int num) {
        if (nums[0] == 0) {
            nums[0] = 2;
        }
        int count = 1;
        for (int i = 0; i < nums.length; i++) {
            if (count == 0 || num == 1) {
                break;
            } else if (nums[i] != 0) {
                count = (num % nums[i]);
            } else {
                nums[i] = num;
                break;
            }
        }
        return nums;
    }

    /*
     * 定义一个找出素数的方法。 思想：一个数n如果没被x整除，则他不会被n/x以上的数整除。 只需要验证是否被素数整除，所以可以略过合数。
     * 找出的素数放入数组中
     */
    public static int[] findNumber(int[] numbers, int number) {
        if (number == 0)
            return numbers;
        if (number == 1) {
            numbers[0] = 1;
            return numbers;
        } else if (numbers[1] == 0)
            numbers[1] = 2;

        int x;
        for (int i = 1; i <= numbers.length; i++) {

            if (numbers[i + 1] != 0 && numbers[i] > number / numbers[i]) {
                while (true) {
                    if (numbers[++i + 1] == 0) {
                        numbers[i + 1] = number;
                        break;
                    }
                }
                break;

            } else if (number % numbers[i] != 0) {
                if (numbers[i + 1] == 0)
                    numbers[i + 1] = number;
                else
                    continue;
            } else
                break;
        }
        return numbers;
    }
}

---

螺旋矩阵

/*
需求：输出边为n的螺旋矩阵，比如n=5时：
    输出 n=5 的螺旋方阵
    1  2  3  4  5
    16 17 18 19 6
    15 24 25 20 7
    14 23 22 21 8
    13 12 11 10 9 

分析：
                区域2
区域1     1   2   3   4   5           
16              17  18  19          6
15  24                          20  7  区域3
14  23          22  21              8
13          12  11  10  9           
                区域4

观察可以得出：
定义一个二维数组用于存储区域内的数字。
i：行   j：列   对应位置的数字：number[i][j]
1.16、24--> i==j+1 && (i+1)*10<=(n+1)*10/2
    number[i][j] = number[i-1][j]+4*(n-j*2-1)  当索引<0时，值取0
2.区域1--> i>j+1 && (j+1)*10<(n+1)*10/2 && i<=(n-j-1)
    number[i][j] = number[i-1][j] - 1 当索引<0时，值取0
3.区域4--> (i+1)*10>(n+1)*10/2 && j<=i && j>n-i-1
    number[i][j] = number[i][j-1] - 1
4.区域2--> j>=i && j<=(n-i-1) 
    number[i][j] = number[i][j-1] + 1
5.区域3--> i>(n-j-1) && i<j
    number[i][j] = number[i-1][j] + 1

*/

class Show {
    Show() {
        int n = 9;
        int num;
        int[][] number = new int[n][n];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                // 16、24
                if (i == j + 1 && (i + 1) * 10 <= (n + 1) * 10 / 2) {
                    number[i][j] = number[i - 1][j] + 4 * (n - j * 2 - 1) - 1;
                }

                // 区域1
                if (i > j + 1 && (j + 1) * 10 < (n + 1) * 10 / 2
                        && i <= (n - j - 1)) {
                    number[i][j] = number[i - 1][j] - 1;
                }

                // 区域4
                if ((i + 1) * 10 > (n + 1) * 10 / 2 && j <= i && j > n - i - 1) {
                    number[i][j] = number[i][j - 1] - 1;
                }

                // 区域2
                if (j >= i && j <= (n - i - 1)) {
                    if (j - 1 < 0)
                        number[i][j] = 1;
                    else
                        number[i][j] = number[i][j - 1] + 1;
                }

                // 区域3
                if (i > (n - j - 1) && i < j) {
                    number[i][j] = number[i - 1][j] + 1;
                }

                num = number[i][j];
                System.out.print(num + "\t");
            }
            System.out.println();
        }
    }
}