int[][] a=new[3][];
a[0]=new int[2];
a[1]=new int[3];
a[2]=new int[4];

int a[][]={{1,2,3},{4,5},{7}};

int a[][];
a[][]={{1,2,3},{4,5},{7}};

public class InputMatrix {
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		int[][] array=new int[2][5];
		System.out.println("请输入10个数");
		for (int i = 0; i < array.length; i++) {
			for (int j = 0; j < array[i].length; j++) {
				array[i][j]=scanner.nextInt();
			}
		}
		
		for (int i = 0; i < array.length; i++) {
			System.out.print("|");
			for (int j = 0; j < array[i].length; j++) {
				System.out.printf("%2s",array[i][j]);
				if(j<array[i].length-1) {
					System.out.print(",");
				}
			}
			System.out.print("|");
			System.out.println();
		}
	}
}

public class SaddlePoint {
	public static void main(String[] args) {
		int[][] a = { { 1, 3, 2 }, { 4, 5, 6 }, { 7, 8, 9 } };
		int maxInRow, minInCol;
		for (int i = 0; i < a.length; i++) {
			maxInRow = 0;
			for (int j = 1; j < a[i].length; j++) {
//				如果在该行中有更大的值
				if (a[i][j] > a[i][maxInRow]) {
//					则记下更大的值得下标
					maxInRow = j;
				}
			}
			// 遍历当前行最大的元素所在的列。
			int k;
			for (k = 0; k < a.length; k++) {
//				如果该列中有更小的值
				if (a[k][maxInRow] < a[i][maxInRow]) {
//					当前行中最大的值在其所在的列中不是最小的
					break;
				}
			}
//			如果找到最后，没有找到更小的值，则说明a[i][maxInRow]是该列中最小的，此时k等于列的长度
			if (k == a.length) {
				System.out.print("鞍点:a[" + i + "][" + maxInRow + "]=" + a[i][maxInRow]);
			}
		}
	}
}

public class FindMaxAndMinInArray {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[] a = new int[10];
        System.out.print("输入10个数:");
        for (int i = 0; i < a.length; i++) {
            a[i] = scanner.nextInt();
        }
        int maxIndex = 0, minIndex = 0;
        for (int i = 1; i < a.length; i++) {
            // 如果找到一个更大的数
            if (a[i] > a[maxIndex]) {
                maxIndex = i;
            }
            // 如果找到一个更小的数
            if (a[i] < a[minIndex]) {
                minIndex = i;
            }
        }
        // 输出最大最小值
        System.out.println("最大值：a[" + maxIndex + "]=" + a[maxIndex] + "，最小值：a[" + minIndex + "]=" + a[minIndex]);
    }
}

/**
 * 冒泡排序，默认升序排列。
 * 如果数组已经有序，则不再排序。
 * 
 * @param array
 */
private static void bubbleSortBetter(int[] array) {
    // 添加一个判断是否交换的标记
    boolean haveSwap = false;
    for (int i = 0, temp; i < array.length - 1; i++) {
        haveSwap = false;
        for (int j = 0; j < array.length - 1 - i; j++) {
            // 如果前一个数比后一个数大
            if (array[j] > array[j + 1]) {
                temp = array[j];
                // 小的数放前面
                array[j] = array[j + 1];
                // 大的数放后面
                array[j + 1] = temp;
                // 经过交换
                haveSwap = true;
            }
        }
        // 如果一轮比较之后,没有交换，则说明已经有序，不需要再排序了
        if (!haveSwap) {
            break;
        }
    }
}

/**
 * 选择排序，升序排序
 * 每次选择一个最小的值放到没有排序的序列的前方。
 * @param a 待排序的数组。
 */
public static void selectionSort(int[] a) {
    // n个元素，需要比较n-1次（2个元素，比较1次，3个元素，比较两次）
    for (int i = 0, temp; i < a.length - 1; i++) {
        // 默认最小值
        int min = i;
        // 遍历没有排序的元素
        for (int j = i + 1; j < a.length; j++) {
            // 如果找到更小的值
            if (a[j] < a[min]) {
                // 记录下这个更小的值
                min = j;
            }
        }
        // 如果找到了更小的值
        if (min > i) {
            temp = a[min];
            a[min] = a[i];
            a[i] = temp;
        }
    }
}

public class DecimalToHexadecimal {

    public static void main(String[] args) {
        // 被除数，十进制数
        int dividend = 16 + 15;
        // 除16取余
        int[] remainders = decimalToHexadecimal(dividend);
        // 逆序打印余数
        System.out.println("(" + dividend + ")10 = (" + printHexadecimal(remainders) + ")16");
    }

    /**
     * 十进制转十六进制
     * 除16取余，逆序排列
     * 
     * @param remainders 保存每个余数的数组
     * @param remainderCounter 到底有多少个余数
     * @return
     */

    private static int[] decimalToHexadecimal(int dividend) {
        // 创建一个临时的数组用来，保存余数
        int[] remainderTemps = new int[20];
        int remainderCounter = 0;
        // 十进制数(被除数)
        // int dividend = 16 + 15;
        // 定义商
        int quotient;
        do {
            // 求商
            quotient = dividend / 16;
            // 求余数
            remainderTemps[remainderCounter++] = dividend % 16;
            // 商作为下次的被除数
            dividend = quotient;
        } while (dividend > 0);
        // 创建一个刚好能保存所有余数的数组
        int[] remainders = new int[remainderCounter];
        // 从临时保存的余数数组中拷贝到
        for (int i = 0; i < remainders.length; i++) {
            remainders[i] = remainderTemps[i];
        }
        // 返回保存余数的数组
        return remainders;
    }

    /**
     * 打印16进制数
     * 
     * @param remainders 保存余数的数组。
     */
    private static String printHexadecimal(int[] remainders) {
        StringBuffer sb = new StringBuffer(remainders.length);
        // 十进制转十六进制口诀：除16取余，逆序排列
        // 逆序打印
        for (int i = remainders.length - 1; i >= 0; i--) {
            if (remainders[i] < 10) {
                // System.out.print(remainders[i]);
                sb.append(remainders[i]);
            } else {
                // System.out.print((char) ('A' + remainders[i] - 10));
                sb.append((char) ('A' + remainders[i] - 10));
            }
        }
        return sb.toString();
    }
}

/**
 * 逆序存储到数组中
 *
 */
public class ReverseStoredInTheArray {

    public static void main(String[] args) {
        int[] a=new int[10];
        Scanner scanner=new Scanner(System.in);
        for (int i = 0; i < a.length; i++) {
            a[a.length-1-i]=scanner.nextInt();
        }
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
    }
}

public class OrderedArrayIsStillOrderedAfterInsertion {

    public static void main(String[] args) {
        // 保存有序序列的数组
        int[] a = new int[20];
        // 有序序列
        int[] b = { 1, 5, 9, 18, 24 };
        // 把有序序列保存到数组中
        for (int i = 0; i < b.length; i++) {
            a[i] = b[i];
        }
        System.out.println("有序序列：");
        printArray(a);

        int toBeInsert;
        // Scanner scanner = new Scanner(System.in);
        // System.out.println("输入一个整数:");
        // toBeInsert=scanner.nextInt();

        // 插入有序序列的最前面
        // toBeInsert = 0;
        // 插入有序序列的中间
        // toBeInsert = 8;
        // toBeInsert = 23;
        // 插入有序序列的最后面
        toBeInsert = 25;
        System.out.println("要插入的元素:" + toBeInsert);
        // 找出要出插入的位置
        int insetIndex = findInsertIndex(a, b.length - 1, toBeInsert);
        System.out.println("插入后的位置：" + insetIndex);
        // 为要插入的元素腾出空间
        makeRoomForInsertion(a, b.length, insetIndex);
        System.out.println("为待插入元素腾出空间：");
        printArray(a);
        // 插入要插入的元素
        a[insetIndex] = toBeInsert;
        System.out.println("插入后的效果：");
        printArray(a);
    }

    /**
     * 查找要插入的元素在有序数组中将要插入的位置。
     * 
     * @param a 有序数组
     * @param orderedSequenceEndIndex 有序数组中最后的元素的下标。
     * @param toBeInserted 要插入的元素
     * @return
     */
    private static int findInsertIndex(int[] a, int orderedSequenceEndIndex, int toBeInserted) {
        int insetIndex = 0;
        int i = 0;
        for (; i <= orderedSequenceEndIndex; i++) {
            // 如果输入的比扫描到的数小
            if (toBeInserted < a[i]) {
                // 则应该在这里插入输入的数
                insetIndex = i;
                break;
            }
        }
        if (insetIndex == 0) {
            insetIndex = i;
            return insetIndex;
        }
        return insetIndex;
    }

    /**
     * 为要插入的元素腾出空间
     * 
     * @param a 保存有序序列的数组
     * @param lastIndexOfNew 插入元素之后形成的新的有序序列的最后一个元素的下标
     * @param insetIndex 要插入的下标
     */
    private static void makeRoomForInsertion(int[] a, int lastIndexOfNew, int insetIndex) {
        // 如果要插入的位置，在原来有序序列的最后面
        if (insetIndex == lastIndexOfNew) {
            // 那么不需要平移元素
            return;
        }
        // 从后向前扫描
        for (int i = lastIndexOfNew + 1, temp; i > insetIndex; i--) {
            // 所有的元素往后移动一格
            temp = a[i];
            a[i] = a[i - 1];
        }
    }

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

/**
 * 二分查找。
 * 
 * @param a 有序数组
 * @param toFind 要查找的整数
 * @return 如果在数组中查找到该元素，则返回该元素的索引，
 *         否则返回-1表示在数组找不到这个元素。
 */
private static int binarySearch(int[] a, int toFind) {
    // 查找序列的开始位置
    int start = 0;
    // 查找序列的结束位置
    int end = a.length - 1;
    int middle;
    while (start <= end) {
        middle = (start + end) / 2;
        // 如果待查找的等于中间值，则说明查找到了，输出该元素的位置
        if (a[middle] == toFind) {
            // System.out.println(toFind + "位于：" + middle + "位置");
            // break;
            // 返回待查找元素的下标
            return middle;
        }
        // 如果待查元素比中间位置的值大，应该到后面的序列去查找
        else if (toFind > a[middle]) {
            // 修改待查找的序列的起始位置为中间值的后一个位置
            start = middle + 1;
        }
        // 如果待查元素比中间值小，应该到前面去查找
        else {
            // 修改待查找的序列的结束位置为中间位置的前面一个位置
            end = middle - 1;
        }
    }
    // 返回一个负数作为下标，表示没有查找到该元素
    return -1;
}

public static void main(String[] args) {
    int[] a = { 1, 2, 7, 8, 9, 10, 23, 45, 67, 89, 98, 123, 134 };
    int toFind = 9;
    
    int index = 0;
    if ((index = binarySearch(a, toFind)) >= 0) {
        System.out.println("数组中  存在" + toFind + "这个元素,a[" + index + "]=" + a[index]);
    } else {
        System.out.println("数组中 不存在" + toFind + "这个元素");
    }
}

/**
 * 水平镜像矩阵，上面的行保存到下面，下面的行保存到上面。
 * 
 * @param a 保存矩阵的二维数组
 */
private static void mirrorHorizontalMatrix(int[][] a) {
    int temp;
    for (int i = 0; i <= (a.length - 1) / 2; i++) {
        for (int j = 0; j < a[i].length; j++) {
            temp = a[i][j];
            a[i][j] = a[a.length - 1 - i][j];
            a[a.length - 1 - i][j] = temp;
        }
    }
}

/**
 * 对矩阵做垂直镜像操作
 * 
 * @param a 保存矩阵的二维数组。
 */
private static void mirrorVertical(int[][] a) {
    int temp;
    for (int i = 0; i < a.length; i++) {
        for (int j = 0; j <= (a[0].length - 1) / 2; j++) {
            temp = a[i][j];
            a[i][j] = a[i][a[i].length - 1 - j];
            a[i][a[i].length - 1 - j] = temp;
        }
    }
}

int[][] a = { 
        { 1, 2, 3 }, 
        { 4, 5, 6 }, 
        { 7, 8, 9 } };
printMatrix(a);
// 水平镜像矩阵
mirrorHorizontalMatrix(a);
printMatrix(a);
// 垂直镜像矩阵
mirrorVertical(a);
printMatrix(a);

/**
 * 判断一个二维数组是否是矩阵。
 * 
 * @param A 保存矩阵的二维数组。
 * @return 如果是矩阵的话，则返回true,否是返回false。
 */
public static boolean isMatrix(int[][] A) {
    for (int i = 1; i < A.length; i++) {
        // 如果其他行的长度与第一行的长度不一样
        if (A[i].length != A[0].length) {
            // 说明不是矩阵
            // System.out.println("不是矩阵");
            return false;
        }
    }
    return true;
}

/**
 * 判断两个矩阵是否是相同类型的矩阵
 * 
 * @param A 保存矩阵的二维数组
 * @param B 另一个保存矩阵的二维数组
 * @return 如果这两个矩阵是相同类型的矩阵，则返回true；否则返回false.
 */
public static boolean isSameMatrix(int[][] A, int[][] B) {
    // 如果两个二维数组，其中有一个不是矩阵，那没什么好说的
    if (!isMatrix(A) || !isMatrix(B)) {
        return false;
    }
    // 如果两个都是矩阵的话，比较行数和第一行的列数即可
    return A.length == B.length && A[0].length == B[0].length;
}

/**
 * 矩阵加法。
 * 
 * @param A 保存矩阵的二维数组
 * @param B 保存矩阵的二维数组
 * @return 保存矩阵相加之后的矩阵的二维数组。
 */
public static int[][] matrixAdd(int[][] A, int[][] B) {
    int[][] C = new int[A.length][A[0].length];
    for (int i = 0; i < A.length; i++) {
        for (int j = 0; j < A[i].length; j++) {
            C[i][j] = A[i][j] + B[i][j];
        }
    }
    return C;
}

public static void main(String[] args) {
    int[][] A = { { 1, 3 }, { 1, 0 }, { 1, 2 } };
    // int[][] A = { { 1, 3, 2 }, { 1, 0, 2 }, { 1, 2, 2 } };
    int[][] B = { { 0, 0 }, { 7, 5 }, { 2, 1 } };
    MatrixTools.printMatrix(A);
    System.out.println("  + ");
    MatrixTools.printMatrix(B);

    // 只有都是同类型的矩阵才可以相加
    if (isSameMatrix(A, B)) {
        // System.out.println("相同类型的数组");
        int[][] C = MatrixTools.matrixAdd(A, B);
        System.out.println("  = ");
        MatrixTools.printMatrix(C);
    } else {
        System.out.println("不是相同类型的矩阵,无法相加");
    }
}

/**
 * 返回矩阵A和矩阵B的乘法，C=AB的结果
 * 
 * @param A 保存矩阵的二维数组
 * @param B 保存另一个矩阵的二维数组
 * @return 保存矩阵A乘以矩阵B的结果AB
 */
public static int[][] matrixMultiplication(int[][] A, int[][] B) {
    // 矩阵C的行数等于矩阵A的行数，C的列数等于B的列数
    int[][] C = new int[A.length][B[0].length];
    // 缓存
    int sumIJ = 0;
    for (int i = 0; i < C.length; i++) {
        for (int j = 0; j < C[i].length; j++) {
            for (int k = 0; k < B.length; k++) {
                // 乘积C的第m行和第n列的元素，
                // 等于矩阵A的第m行元素与矩阵B的第n列元素对应的元素的乘积的和
                sumIJ = sumIJ + A[i][k] * B[k][j];
            }
            C[i][j] = sumIJ;
            // 计算下一个元素之前先清零，去除上一次的计算结果
            sumIJ = 0;
        }
    }
    return C;
}

/**
 * 判断矩阵是否可以相乘。
 * 当A的列数，等于矩阵B的行数，是A和B可以相乘。
 * 
 * @param A 保存矩阵的二维数组
 * @param B 保存另一矩阵的二维数组
 * @return 如果可以相乘，则返回true,不可用相乘，则返回false。
 */
public static boolean canBeMultiplied(int[][] A, int[][] B) {
    // 首先要都是矩阵
    // 当A的列数，等于矩阵B的行数，是A和B可以相乘
    return MatrixTools.isMatrix(A) && MatrixTools.isMatrix(B) && A[0].length == B.length;
}

private static void printmatrixMul(int[][] A, int[][] B) {
    MatrixTools.printMatrix(A);
    System.out.println("   *");
    MatrixTools.printMatrix(B);
    System.out.println("   =");
    // 当A的列数，等于矩阵B的行数，是A和B可以相乘
    if (MatrixTools.canBeMultiplied(A, B)) {
        // System.out.println("可以相乘");
        int[][] C = MatrixTools.matrixMultiplication(A, B);
        MatrixTools.printMatrixMoreBeautiful(C);
    } else {
        System.out.println("不可相乘");
    }
}

/**
 * 判断一个二维数组是否是矩阵。
 * 
 * @param A 保存矩阵的二维数组。
 * @return 如果是矩阵的话，则返回true,否是返回false。
 */
public static boolean isMatrix(int[][] A) {
    for (int i = 1; i < A.length; i++) {
        // 如果其他行的长度与第一行的长度不一样
        if (A[i].length != A[0].length) {
            // 说明不是矩阵
            // System.out.println("不是矩阵");
            return false;
        }
    }
    return true;
}

/**
 * 打印矩阵
 * 
 * @param a 保存矩阵的二维数组?
 */
public static void printMatrix(int[][] a) {
    for (int i = 0; i < a.length; i++) {
        System.out.print("|");
        for (int j = 0; j < a[i].length; j++) {
            if (j > 0) {
                // System.out.print(",");
                System.out.print(" ");
            }
            System.out.print(a[i][j]);
        }
        System.out.println("|");
    }
}

/**
 * 更美观的打印矩阵.
 * 如果矩阵中的最大值为3位数，则打印的每个矩阵元素都占三个位，不足的以0补齐。
 * 
 * @param a 保存矩阵的二维数组。
 */
public static void printMatrixMoreBeautiful(int[][] a) {
    int max = findMax(a);
    // System.out.println("max=" + max);
    int bits = 0;
    do {
        max = max / 10;
        bits++;
    } while (max > 0);
    // System.out.println("bits="+bits);
    printMatrixFormatted(a, bits);
}

/**
 * 查找矩阵中的最大值（查找二维数组中的最大值）
 * 
 * @param a 保存矩阵的二维数组。
 * @return 矩阵的最大元素。
 */
private static int findMax(int[][] a) {
    int max = Integer.MIN_VALUE;
    for (int i = 0; i < a.length; i++) {
        for (int j = 0; j < a[i].length; j++) {
            if (a[i][j] > max) {
                max = a[i][j];
            }
        }
    }
    return max;
}

/**
 * 打印格式化的矩阵，默认打印两位数，如果一个数小于10，则在前面补0。以占满两个位置。
 * 
 * @param a 保存矩阵的二维数组?
 */
public static void printMatrixFormatted(int[][] a, int numLen) {
    for (int i = 0; i < a.length; i++) {
        System.out.print("|");
        for (int j = 0; j < a[i].length; j++) {
            if (j > 0) {
                // System.out.print(",");
                System.out.print(" ");
            }
            // 格式化输出,%02d，其中
            // d表示数据类型为整数,
            // 2表示这个数占据两位,
            // 0表示不足的在前面补上0
            System.out.printf("%0" + numLen + "d", a[i][j]);
        }
        System.out.println("|");
    }
    System.out.println();
}

int[][] A = { { 5, 2, 4 }, { 3, 8, 2 }, { 6, 0, 4 }, { 0, 1, 6 } };
int[][] B = { { 2, 4 }, { 1, 3 }, { 3, 2 } };
printmatrixMul(A, B);

int[][] A = { { 1, 2, 3 }, { 4, 5, 6 } };
int[][] B = { { 7, 8 }, { 9, 10 }, { 11, 12 } };
printmatrixMul(A, B);

int[][] A = { { 1, 2 }, { 3, 4 } };
int[][] B = { { 2, 0 }, { 1, 2 } };
System.out.println("AB=");
printmatrixMul(A, B);
System.out.println("BA=");
printmatrixMul(B, A);

public static void main(String[] args) {
    int length = 20;
    int[][] yh = yangHui(length);
    printYangHui(yh);
    // printHangHui1(length);
}

private static int[][] yangHui(int length) {
    // 变长的二维数组
    int[][] yh = new int[length][];
    for (int i = 0; i < yh.length; i++) {
        // 创建第2维的数组
        yh[i] = new int[i + 1];
    }
    //
    for (int i = 0; i < length; i++) {
        for (int j = 0; j < yh[i].length; j++) {
            // 第1列和最后一列的值为1
            if (j == 0 || i == j) {
                yh[i][j] = 1;
            } else {
                // 当前元素，等于正上方的元素 与 正上方的前一个元素的和
                yh[i][j] = yh[i - 1][j] + yh[i - 1][j - 1];
            }
        }
    }
    return yh;
}

/**
 * 打印杨辉三角形
 * 
 * @param yh 保存杨辉三角形的变长二维数组.
 */
private static void printYangHui(int[][] yh) {
    // 杨辉三角形最大值，最后一行的中间位置的值
    int max = yh[yh.length - 1][yh.length / 2];
    // 格式化打印，每个数的长度都与最大的数的长度一样
    printYangHuiFormatted(yh, countBits(max));
}

/**
 * 格式化打印杨辉三角形
 * 
 * @param a 保存杨辉三角形的二维数组
 * @param maxNumLength 杨辉三角形中最大的数字有多少个数字字符。
 */
public static void printYangHuiFormatted(int[][] a, int maxNumLength) {
    for (int i = 0; i < a.length; i++) {
        for (int j = 0; j < a[i].length; j++) {
            // 打印分隔符
            if (j > 0) {
                System.out.print(" ");
            }
            // 打印空白符，使得小的的数的宽度和最大的数的宽度一样
            for (int k = 0; k < maxNumLength - countBits(a[i][j]); k++) {
                System.out.print(" ");
            }
            // 打印元素
            System.out.print(a[i][j]);
        }
        System.out.println();
    }
    System.out.println();
}

/**
 * 计算一个整数有几位数。
 * 
 * @param num 整数
 * @return 该整数有多少个整数。
 */
public static int countBits(int num) {
    int bits = 0;
    do {
        num = num / 10;
        bits++;
    } while (num > 0);
    return bits;
}

public class HW_13_Intersection {
    public static void main(String[] args) {
        int[] A = { 21, 3, 33, 89, 16 };
        int[] B = { 33, 78, 15, 16, 48, 57 };
        int[] C1 = intersection(A, B);
        ArrayTools.printArray(C1);
        ArrayTools.printArray(intersection2(A, B));
    }

    /**
     * 求数组的交集
     * 
     * @param A 数组A
     * @param B 数组B
     * @return 数组A和数组B的交集
     */
    private static int[] intersection(int[] A, int[] B) {
        int[] C;
        if (A.length < B.length) {
            C = new int[A.length];
        } else {
            C = new int[B.length];
        }
        int count = 0;
        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < B.length; j++) {
                if (A[i] == B[j]) {
                    // System.out.println(A[i]);
                    C[count++] = A[i];
                }
            }
        }
        int[] D = new int[count];
        for (int i = 0; i < count; i++) {
            D[i] = C[i];
        }
        return D;
    }

    /**
     * 求两个数组的交集，求两个数组共有的元素.
     * 
     * @param A 数组A
     * @param B 数组B
     * @return 数组A和数字B的交集
     */
    private static int[] intersection2(int[] A, int[] B) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < B.length; j++) {
                if (A[i] == B[j]) {
                    list.add(A[i]);
                }
            }
        }
        return list.stream().mapToInt(Integer::valueOf).toArray();
    }
}

/**
 * 输入一个3位的整型数，输入其百位、十位及个位数；
 */
public class SplitInteger {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int hundredDigit, tenDigit, singleDigits;
        int input = scanner.nextInt();
        // 除以100，取出百位数
        hundredDigit = input / 100;
        // 减去百位数，剩下十位数和个位数，再除以10，取出十位数。
        tenDigit = (input - hundredDigit * 100) / 10;
        // 求余10，取出个位数
        singleDigits = input % 10;
        System.out.println(input + "的百位数:" + hundredDigit + ",十位数:" + tenDigit + ",个位数:" + singleDigits);
    }
}

/**
 * 判断一个数是否是质数
 * 
 * @param n 一个整数
 * @return 如果n是质数，则返回true，否则返回false
 */
public static boolean isPrime(int n) {
    // 2和3都是质数
    if (n <= 3) {
        // 质数都要大于1
        return n > 1;
    }
    int sqrt = (int) Math.sqrt(n);
    for (int i = 2; i <= sqrt; i++) {
        // 如果n能被小于等于sqrt(n)的整数整除的话，不符合质数的定义，则说明不是质数
        if (n % i == 0) {
            return false;
        }
    }
    return true;
}

/**
 * 百分制转成等级制-利用 if
 */
public class ConvertPercentileScoresToGradedScoresByIf {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int scores = scanner.nextInt();
        if (scores > 100) {
            System.out.println("成绩必须小于100");
        } else if (scores >= 90) {
            System.out.println("A");
        } else if (scores >= 80) {
            System.out.println("B");
        } else if (scores >= 70) {
            System.out.println("C");
        } else if (scores >= 60) {
            System.out.println("D");
        } else if (scores >= 0) {
            System.out.println("E");
        } else {
            System.out.println("成绩必须大于0");
        }
    }
}

/**
 * 百分制转成等级制-利用switch
 */
public class ConvertPercentileScoresToGradedScoresBySwitch {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int scores = scanner.nextInt();
        if (scores >= 0 && scores <= 100) {
            switch (scores / 10) {
            case 10:
            case 9:
                System.out.println("A");
                break;
            case 8:
                System.out.println("B");
                break;
            case 7:
                System.out.println("C");
                break;
            case 6:
                System.out.println("D");
                break;
            default:
                System.out.println("E");
            }
        } else {
            System.out.println("请输入[1,100]区间内的数");
        }
    }
}

public static void main(String[] args) {
    // Scanner scanner = new Scanner(System.in);
    int lirun;
    // lirun = scanner.nextInt();
    lirun = 600;
    double jiangjin = 0;
    if (lirun <= 10) {
        jiangjin += lirun * 0.1;
    } else if (lirun < 20) {
        jiangjin += 0.1 + (lirun - 10) * 0.075;
    } else if (lirun < 40) {
        jiangjin += 0.1 + (lirun - 10) * 0.075 + (lirun - 20) * 0.05;
    } else if (lirun < 60) {
        jiangjin += 0.1 + (lirun - 10) * 0.075 + (lirun - 20) * 0.05 + (lirun - 40) * 0.03;
    } else if (lirun < 100) {
        jiangjin += 0.1 + (lirun - 10) * 0.075 + (lirun - 20) * 0.05 + (lirun - 40) * 0.03 + (lirun - 60) * 0.015;
    } else {
        jiangjin += 0.1 + (lirun - 10) * 0.075 + (lirun - 20) * 0.05 + (lirun - 40) * 0.03 + (lirun - 60) * 0.015
                + (lirun - 100) * 0.01;
    }
    System.out.println(jiangjin);
}

/**
 * 计算s＝1+2+…+100。
 */
public class Sum1to100 {
    public static void main(String[] args) {
        int sum=0;
        for(int i=1;i<=100;i++)
        {
            sum+=i;
        }
        System.out.println(sum);
    }
}

/**
 * 求100到999的水仙花数
 * 例如： 153 = 1*1*1 + 5*5*5 + 3*3*3.
 */
public class NarcissisticNumber {
    public static void main(String[] args) {
        int hundreds, tens, ones;
        System.out.print("水仙花数:");
        for (int i = 100; i < 999; i++) {
//            除以100得到百位数
            hundreds = (i / 100);
//            求余100得到十位数和个位数，再除以10得到十位数
            tens = i % 100 / 10;
//            求余10得到十位数
            ones = i % 10;
            if (i == (hundreds * hundreds * hundreds + tens * tens * tens + ones * ones * ones)) {
                System.out.print(i+" ");
            }
        }
    }
}

public class PerfectNumber {
    public static void main(String[] args) {
        for (int i = 2,sumOfFactors=0; i < 1000; i++) {
//            因子的和
            sumOfFactors=0;
            for(int j=1;j<i;j++) {
//                如果j是i的因子
                if(i%j==0) {
//                    因子累加
                    sumOfFactors+=j;
                }
            }
//            如果一个数恰好等于它的因子之和，那么就是完数
            if(i==sumOfFactors) {
                System.out.println("完数："+i);
            }
        }
    }
}

/**
 * 11、求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+2222+22222 (此时
 * 共有5个数相加)，几个数相加有键盘控制。
 */
public class Sum_a_aa_aaa {
    public static void main(String[] args) {
        int sum=0;
        int a;
        int times;
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入a:");
        a = scanner.nextInt();
        System.out.println("输入个数:");
        times = scanner.nextInt();
        
        System.out.print("sum=");
        for (int i = 0; i <=times; i++) {
            int temp = a;
            for (int j = 1; j < i; j++) {
                temp = temp * 10 + a;
            }
            System.out.print(temp);
            if(i<times) {
                System.out.print("+");
            }
            sum=sum+temp;
        }
        System.out.println("\n   ="+sum);
    }
}

public static void main(String[] args) {
    double fenmu = 1;
    double fenzi = 2;
    double sum = 0.0;
    double temp;
    for (int i = 0; i < 20; i++) {
        if (i > 0)
            System.out.print(" + ");
        System.out.print((int)fenzi + "/" + (int)fenmu);
        // 求和
        sum += fenzi / fenmu;
        // 记下分母的值
        temp = fenmu;
        // 前一个的分子作为下次计算的分母
        fenmu = fenzi;
        // 前一个分子的值加上前一个分母的值作为下次计算的分子
        fenzi = fenzi + temp;
        if((i+1)%5==0) {
            System.out.println();
        }
    }
    System.out.println("=" + sum);
}