有两道试题要请问大家

Question

(a+b)的n次幂的展开式中各项的系数很有规律，对于n=2，3，4时分别是：1 2 1， 1 3 3 1，1 4 6 4 1。这些系数构成了著名的杨辉三角形：
                 1
               1   1
              1  2  1
            1  3   3   1
          1  4   6   4   1
        1  5  10  10   5   1下列的程序给出了计算第m层的第n个系数的计算方法，试完善之（m，n都从0算起）。
public static int f(int m, int n)
{
if(m==0) return 1;
if(n==0 || n==m) return 1;
return __________________________; 
}
任意一个5位数，比如：34256，把它的各位数字打乱，重新排列，可以得到一个最大的数：65432，一个最小的数23456。求这两个数字的差，得：41976，把这个数字再次重复上述过程（如果不足5位，则前边补0）。如此往复，数字会落入某个循环圈（称为数字黑洞）。
比如，刚才的数字会落入：[82962, 75933, 63954, 61974] 这个循环圈。请编写程序，找到5位数所有可能的循环圈，并输出，每个循环圈占1行。其中5位数全都相同则循环圈为 [0]，这个可以不考虑。循环圈的输出格式仿照：
[82962, 75933, 63954, 61974]
其中数字的先后顺序可以不考虑。

Answer 1

第一题：f((m-1),(n-1))+f((m-1),n); 
就是其左上角的数，与正上面的数之和。

Answer 2

学java的人。思维一定要清晰，脑袋笨拙的，还是不建议做java，逻辑思维比较复杂。

Answer 3

import java.util.Scanner;public class PascalTriangle {
 public static void main(String[] args) {
  
  System.out.print("Please input a digit for pascal triangle: ");
  
  Scanner scanner = new Scanner(System.in);
  
  final int num = scanner.nextInt();
  
  int[][] ary = getPascalTriangle(num);
  
  for(int[] item: ary){
   for(int value: item){
    System.out.print((value > 0? value: "") + " ");
   }
   System.out.println();
  } } private static int[][] getPascalTriangle(final int num) {
  int[][] ary = new int[num][num];
  
  for(int i = 0; i < ary.length; i++){
   ary[i][0] = 1;
   ary[i][i] = 1;
  }
  
  for(int i = 1; i < ary.length; i++){
   for(int j = 1; j <= i; j++){
    ary[i][j] = ary[i-1][j-1] + ary[i-1][j];
   }
  }
  return ary;
 }
}
百度一下

Answer 4

第二题我的思路。
先定义一个数组，长度99999。
int[] record = new int[99999];
for (int i = 1; i < 99999; i++) {
int temp = i;
while(true) {
int minValue = getMinValue(temp);
if (record[minValue] == 0) {
//没出现过，设置为已出现
record[minValue] = 1;
} else {
if (record[minValue] == 1) {
//出现过，黑洞成型，输出黑洞值。
......
record[minValue] == 2;
break;
} else {
//出现过，而且输出过黑洞值，退出，看下一个值。
break;
}
}
int maxValue = getMaxValue(temp);
temp = maxValue - minValue;
}
}
细节没具体写，估计应该可以完成任务吧。

Answer 5

终于让我做出第二题了，不容易啊import java.util.*;public class Test 
{
public static int maxNum(int num)
{
int[] place = new int[5];
for (int i = 0; i < 5; i++)
{
place[i] = num % 10;
num /= 10;
}
Arrays.sort(place);
int maxNum = 0;
for (int i = 4; i >= 0; i--)
{
maxNum *= 10;
maxNum += place[i];
}
return maxNum;
}

public static int minNum(int num)
{
int[] place = new int[5];
for (int i = 0; i < 5; i++)
{
place[i] = num % 10;
num /= 10;
}
Arrays.sort(place);
int minNum = 0;
for (int i = 0; i < 5; i++)
{
minNum *= 10;
minNum += place[i];
}
return minNum;
}

public static void main(String[] args)
{
int[] bNumUsed = new int[100000]; //用来标记数字，-1表示没有用过，不为-1表示在第几轮的循环里面
ArrayList<ArrayList<Integer>> circleList = new ArrayList<ArrayList<Integer>>();
ArrayList<Integer> circle = new ArrayList<Integer>();

for (int i = 0; i < bNumUsed.length; i++)
{
bNumUsed[i] = -1;
}

loop:
for (int i = 0; i < 100000; i++)
{
//System.out.println(i);
if (bNumUsed[i] != -1)
{
continue loop;
}
for (int t = i; t != 0;)
{
if (bNumUsed[t] == -1)
{
bNumUsed[t] = i;
circle.add(t);
t = maxNum(t) - minNum(t);
}
else if (bNumUsed[t] != i)
{
circle = new ArrayList<Integer>();
continue loop;
}
else
{
t = circle.indexOf(t);
for (int j = 0; j < t; j++)
{
circle.remove(0);
}
circleList.add(circle);
circle = new ArrayList<Integer>();
continue loop;
}
}
}

for (ArrayList<Integer> cir : circleList)
{
System.out.println(cir);
}
}
}

Answer 6

第一题：
就是杨慧三角
public class Yanghui {    public static void main(String[] args) {
        Yanghui yang = new Yanghui();
        yang.printYanghuiTriangle(6);
    }    public void printYanghuiTriangle(int lines) {
        int[] line = new int[lines];
        int maxLen = getMaxLen(lines);
        for(int i = 0; i < lines; i++) {
            line[0] = line[i] = 1;
            for(int j = 1, k = i / 2, pre = line[0]; j <= k; j++) {
                int cur = line[j];
                line[i - j] = line[j] += pre;
                pre = cur;
            }
            printLine(line, i + 1, maxLen);
        }
    }    private int getMaxLen(int lines) {
        int k = lines / 2;
        long maxNum = factorial(k + 1, lines - 1) / factorial(1, lines - 1 - k);
        return getLength(maxNum);
    }    private long factorial(int start, int num) {
        long result = start > 0 ? start : 1L;
        while(num > start) {
            result *= num--;
        }
        return result;
    }    private int getLength(long num) {
        int len = 0;
        while(num > 0L) {
            num /= 10L;
            len++;
        }
        return len;
    }    private void printLine(int[] yanghui, int line, int width) {
              for(int i = 0; i < line; i++) {
         
            
            System.out.print(yanghui[i]+" ");
        }
        System.out.println();
        if(width > 1) {
            System.out.println();
        }
    }
}