面试题记1

希望各位看客们能积极提供答案

1）125874和它的两倍251748，包含着同样的数字，只是顺序不同。找出最小的正整数x，使得2x，3x，4x，5x，和6x都包含有相同的数字。

2）求100！各位数之和

3）是用从1到9所有数字，将其任意的连接起来，使之组成十进制数，会得到不同的集合。{2,5,47,89,631}就是比较有趣的集合，它的所有数都属于质数，请问满足1-9都是用且只是用一次，而所有数都是质数的集合有多少个？

4）求满足x+y,x-y,x+z,x-z,y+z,y-z都是完全平方数，且x>y>z>0的最小x+y+z

5）perter有九个4面（金字塔形）骰子每个分别标1,2,3,4，colin有六个六面骰子，每个分别标1,2,3,4,5,6，perter和colin摇骰子，然后比较他们得到的总和，总和最高的获胜，如果相等的话则是平局。请问perter赢colin的概率是多少，结果以7位小数0.abcdefg的形式给出。

解答（面试的时候都没想出来，目前就想出一个来，以后慢慢补充答案吧，感觉这些题是给学数学的人做的，鄙人数学一直很烂，所以没办法，唉。）

2）其实这个考的是大数的乘法，100！这个数在任何语言里都无法找到可以容纳它的类型，所以只能自己定义结构来做了，（其实面试的时候也想到了解法，但是感觉不够好结果没写，后来也没想到更好的，悲催，而且感觉自己写代码的能力还不够强，在60分钟的时间里很难将代码调试通过，后来就放弃了。事实后面证明完成这个代码还是花了一个上午的时间的。写代码能力有待加强啊。）

其实这里用到的主要思想在大学的课程里是有的，就是计算机组成原理里的串行进位链，这里只要用数组（或者其他结构，比如链表，队列都可以，我用java实现的，但是为了能更简单的转化为C的代码，这里就采用了数组来实现）保存计算的中间结果的各个位，数组下标从小到大对应保存中间结果的从低到高位来保存，计算方法用例子来说明吧：

比如a=123456789,b=123456789123456789,那么用数组A={1,2,3,4,5,6,7,8,9.-1-1.....}保存a,B={1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9,-1,-1.-1.....}保存b（这里后面的数最好初始化为一个特殊值，我用的-1，这个特殊值是为运算时预设的循环停止条件，后面代码里可以看到。）那么做第一次乘法运算的时候就用A[0]乘以B的每个元素，期间要注意保存进位的值。这样就可以得到一个中间结果用res数组保存，我们另外再申请一个足够大的数组result用来保存最后的结果，第一次运算的时候将中间结果res拷贝到result保存，再将res清空，留待下次使用。第二次乘法的时候也就是A[1] * B我们又可以得到一个中间结果同样存放在res中，然后我们要做的就是上一次的中间结果和这一次的中间结果的加法运算，但是做加法之前我们要对第二次中间结果做一个移位操作，因为第二次的A[1]是相当于实际运算中的十位位置上的数，所以要将中间结果乘以10然后再做加法运算，加法运算得到的中间结果同样保存在result中留给下一轮加法运算，然后同样要清空res留作下轮乘法运算保存中间结果时使用，第三轮就是百位上的乘法了，也就是A[2] * B,得到的结果同样要做移位，只是移位的位数由上次的移动一位变成了两位，因为这是百位上的乘法，也就是10的平方，所以要移动两位，后面的格轮运算与之前的分析一样。这里要注意的是要自己先估算好做运算的两个数的大概大小，这样方便你预设运算中用到的数组的大小。这种方法可以计算任意大小的两个整数的乘法运算，只要你机器的内存够用就行。

下面是详细的实现代码：

public class Mytest
{
    public static void main(String[] args)
    {
        int i = 0;
        int [] result = test();
        Stack<Integer> s = new Stack<Integer>();
        while(result[i] != -1)
        {
            s.push(result[i++]);
        }
        System.out.println(s.size());
        while(!s.empty())
        {
            System.out.print(s.pop());
        }
    }
    private static int [] test()
    {
        int [] result = new int [200];
        result[0] = 1;
        for(int i = 1; i < 200; i++)
        {
            result[i] = -1;
        }
        for(int i = 1;i <= 100; i++)
        {
            result = bigNumberMutiply(result,numToArray(i));
        }
        int i = 0;
        int sum = 0;
        while(result[i] != -1)
        {
            sum += result[i++];
        }
        System.out.println(sum);
        return result;
    }
    private static int [] bigNumberMutiply(int [] a,int [] b)
    {
        int i = 0, j = 0;
        int carryValue = 0;
        int [] result  = new int [200];
        int [] tempRes  = new int [200];
        
        for(int n = 1; n < 200; n++)
        {
            result[n] = -1;
            tempRes[n] = -1;
        }
        while(b[j] != -1)
        {
            while(a[i] != -1)
            {
                int temp = b[j] * a[i] + carryValue;
                result[i] = temp % 10;
                carryValue = temp / 10;
                i++;
                if(carryValue != 0 && a[i] == -1)
                {
                    result[i] = carryValue;
                    break;
                }
            }
            i = 0;
            carryValue = 0;
            if(j == 0)
            {
                int n = 0;
                while(result[n] != -1)
                {
                    tempRes[n] = result[n];
                    n++;
                }
            }
            else
            {
                result = leftShiftNum(result,j);
                tempRes = add(result, tempRes);
            }
            resetArray(result);
            j++;
        }
        return tempRes;
    }
    private static int [] resetArray(int [] a)
    {
        for(int i = 0; i < a.length; i++)
        {
            a[i] = -1;
        }
        return a;
    }

//将数组保存的中间结果左移n位，相当于将这个大数乘以10的n次方
    private static int [] leftShiftNum(int [] a,int n)
    {
        if(n == 0)
            return a;
        int i = 0;
        while(a[i] != -1)
        {
            i++;
        }
        while(i >= 0)
        {
            a[i+n] = a[i];
            i--;
        }
        for(i = 0; i < n; i++)
        {
            a[i] = 0;
        }
        return a;
    }

//将一个整形的数转换成数组保存
    private static int [] numToArray(int n)
    {
        int [] a = new int[100];//数组的大小取决于n的大小，这里设置的这个值可以容纳一般的需要
        for(int i = 1; i < a.length; i++)
        {
            a[i] = -1;
        }
        int i = 0;
        while(n != 0)
        {
            a[i++] = n % 10;
            n = n / 10;
        }
        return a;
    }

//以串行进位链的方式模拟两个大数的相加
    private static int [] add(int [] a,int [] b)
    {
        int i = 0;
        int [] c = new int[a.length];
        int carryValue = 0;//用于保存计算过程中的进位值,如9+9=18，需要进位，进位值为1
        resetArray(c);//用于保存最后加法结果的数组
        while(a[i] != -1 && b[i] != -1)//如果还没运算到任何一个数的最高位则继续下一位的加法运算
        {
            
            int temp = a[i] + b[i] + carryValue;
            if(temp < 10)
            {
                c[i] = temp;
                carryValue = 0;
            }
            else
            {
                c[i] = temp % 10;
                carryValue = temp/10;
            }
            i++;
        }
        if(a[i] == -1)//如果运算时a的最高位先到，比如a=12,b=1234,则上述循环后还需单独处理b千位和百位 （1）
        {//如果b的高位还有值未处理，或者a的最高位运算后有进位值（可以尝试一下a=1,b=9999这种特殊情况就会明白了）
            while(b[i] != -1 || carryValue != 0)
            {
                if(b[i] == -1)
                {
                    c[i] = carryValue;
                    carryValue = 0;
                }
                else
                {
                    int temp = b[i] + carryValue;
                    if(temp < 10)
                    {
                        c[i] = temp;
                        carryValue = 0;
                    }
                    else
                    {
                        c[i] = temp%10;
                        carryValue = temp/10;
                    }
                }
                i++;
            }
        }
        if(b[i] == -1)//同（1）
        {
            while(a[i] != -1 || carryValue != 0)
            {
                if(a[i] == -1)
                {
                    c[i] = carryValue;
                    carryValue = 0;
                }
                else
                {
                    int temp = a[i] + carryValue;
                    if(temp < 10)
                    {
                        c[i] = temp;
                        carryValue = 0;
                    }
                    else
                    {
                        c[i] = temp%10;
                        carryValue = temp/10;
                    }
                }
                i++;
            }
        }
        return c;
    }
}

这个题的最后结果是：100！长度为158位，

值为：

93326215443944152681699238856266700490715968264381621468592963895217599

993229915608941463976156518286253697920827223758251185210916864000000

000000000000000000，

各位数之和为：648