今天去华为赛门铁克面试被提到的一个有关问题（JAVA）

今天去华为赛门铁克面试被提到的一个问题（JAVA）String str 5673454322...............323223str是一
今天去华为赛门铁克面试被提到的一个问题（JAVA）
String str = "5673454322...............323223";
str是一个无穷大的数字,一个long都无法放入，假设一个n值是7。
面试官提问：如何使得这个数字可以被n整除？？？

[解决办法]
Java code
    public static void main(String[] args) {        BigInteger big = new BigInteger("54354358093245892583457839730957349857394857367935384895");        System.out.println("余数是"+big.divideAndRemainder(BigInteger.valueOf(7))[1].toString());    }
[解决办法]
Java codepublic static void main(String[] args) {        String str = "54354358093245892583457839730957349857394857367935384895";        int n= 7;        String yushu = "";        if(str.length()<5){            yushu=String.valueOf(Integer.parseInt(str)%n);        }else{        for (int i = 0; i < str.length()/5; i=i+5) {                        String temp = yushu+str.substring(i, i+5);            int cloum = Integer.parseInt(temp);            int yu = cloum%n;                        if(yu!=0){                yushu=String.valueOf(yu);            }else{                yushu="";            }        }        }        if(yushu.length()<=0||"0".equals(yushu)){            System.out.println("可以被整除");        }else{            System.out.println("不可以被整除");        }            }
[解决办法]
题目翻译一下：有不定大小的数字x，求与x之间差值最小的7的公约数，给出差值大小
例：
  x = 15
  设y,且y%7=0
  答案就是 x+(y-x)
小于long长度的数字直接用long计算
大于long长度的算法没想好，哈哈

[解决办法]
探讨

题目翻译一下：有不定大小的数字x，求与x之间差值最小的7的公约数，给出差值大小
例：
   x = 15
   设y,且y%7=0
   答案就是 x+(y-x)
小于long长度的数字直接用long计算
大于long长度的算法没想好，哈哈

[解决办法]
Java code    public static void main(String[] args) {        final int leg=18;        StringBuilder str=new StringBuilder("49793821479387619794872314840");        int n=7;        long count=0;                while(true){            long num;            if(str.length()<=leg){                num=Long.parseLong(str.substring(0, str.length()));                count+=num%n;                break;            }else{                num=Long.parseLong(str.substring(0, leg));                count+=num%n;                str.delete(0, leg);            }        }        System.out.println(count%n==0?"可以":"不可以");    }
[解决办法]
探讨

BigInteger会有多大，String可以直接转成他么，我觉得面试人的问题是说似乎任何类型都不能放下这个数？

[解决办法]
就我的观点来看，这应该是一道大数乘法的变形题，基本思路如下：
将大数从最高位开始截取k位（将这k位转化为数字后应该在long范围之内），然后进行除法运算，再截取k-1位，将其与所得余数连接。依次进行，如果最后一次运算余数为零说明能被n整除。
上面的思路假设了除数在long范围内
[解决办法]


这个是有规律的，之后根据同余定理计算



其中：
i — 从右边数起的第几位数字
xi — 从右边数起第 i 位上的数字值
p — 总共的数字位数
n — 模几
k — 计算结果
  
[解决办法]
楼上的兄弟们都小学没有毕业啊。。。题目也没看懂。。
判断str 是否被n整除，没让判断mod后的值，明显用小学的割尾法去做。。。。
[解决办法]
从高位开始逐个读入字符串，然后mod 7，记录余数，读到下一位时将余数*10+当前的值，继续mod 7，记录余数......

String str = "5673454322...............323223"; 
 
一下为余数部分
5 0 0 3 6 2 3 6 0 2 1......
[解决办法]
Java codeString a = "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";                char[] arr = a.toCharArray();        int[] int_array = new int[arr.length];        for(int j=0;j<arr.length;j++){            int_array[j]=arr[j]-48;        }                for(int i = 0 ; i < int_array.length-3; i++){            int_array[i+3]=(int_array[i+3]-int_array[i]);            int_array[i] = 0;        }        int result = (int_array[arr.length-1]+int_array[arr.length-2]*10+int_array[arr.length-3]*10*10)%7;        System.out.println(result<0?result+7:result);//        System.out.println(Integer.parseInt(a)%7);
[解决办法]
Java codepublic static void check(String str){        String tmp = str;        if(tmp.length() < String.valueOf(Long.MAX_VALUE).length()){            long last = Long.parseLong(tmp);            long re = last % 7;            if(re == 0){                System.out.println("over:"+re);            }else{                System.err.println("err:"+re);            }            return;        }                int l = Integer.parseInt(tmp.substring(tmp.length() - 1, tmp.length()));        int h = Integer.parseInt(tmp.substring(tmp.length() - 4, tmp.length() - 1));        int e = h - 2*l;                tmp = tmp.substring(0, tmp.length() - 4);        tmp += String.valueOf(e);        check(tmp);    }
[解决办法]
以n-1为长度从低到高为字符串分割，然后对每部分进行mod n运算，最后累加这些和再mod n
例
12345687878798872 % 7
12345 % 7 = 4
687878 % 7 = 2
798872 % 7 = 4

（4+2+4） % 7 = 3
[解决办法]
public class Test{
public static void main(String[] args) {
//10求余7等于3 100->2 1000->6 10000->4 100000->5 1000000->1  后面为循环10000000->3 。。。。
//20%7=2*(10%7)  300%7=3*(100%7)....... (如果右边的结果大于7请不要纠结这个问题)
String s = "143343434434";
int st = Integer.parseInt(s.substring(s.length()-1));//先把个位数抽出来，因为它不再规律之内

String s1= s.substring(0, s.length()-1);//抽出个位剩余的数


int last = s1.length()%6;//6为循环基数。比如 s1为15位， 那么最大的3位就要另外处理
String ss1 = s1.substring(0, last);

String ss2 = s1.substring(last, s1.length());//抽出另外需要处理的

if (!ss1.equals("")) {
int k = 1;
char ch[]=ss1.toCharArray();
for (int i = ch.length-1; i >=0; i--) {
if (k==1) {
st+=Integer.parseInt( Character.toString(ch[i]))*3;
k+=1;
}
else if (k==2) {
st+=Integer.parseInt( Character.toString(ch[i]))*2;
k+=1;
}
else if (k==3) {
st+=Integer.parseInt( Character.toString(ch[i]))*6;
k+=1;
}
else if (k==4) {
st+=Integer.parseInt( Character.toString(ch[i]))*4;
k+=1;
}
else if (k==5) {
st+=Integer.parseInt( Character.toString(ch[i]))*5;
k+=1;
}
else if (k==6) {
st+=Integer.parseInt( Character.toString(ch[i]))*1;//这个其实不会参与进来
k+=1;
}
}
}

//下面是完整的循环的
if (!ss2.equals("")) {
int k = 1;
char ch[]=ss2.toCharArray();
for (int i = ch.length-1; i >=0; i--) {
if (k%6==1) {
st+=Integer.parseInt( Character.toString(ch[i]))*3;
k++;
}
else if (k%6==2) {
st+=Integer.parseInt( Character.toString(ch[i]))*2;
k++;
}
else if (k%6==3) {
st+=Integer.parseInt( Character.toString(ch[i]))*6; 
 
k++;
}
else if (k%6==4) {
st+=Integer.parseInt( Character.toString(ch[i]))*4;
k++;
}
else if (k%6==5) {
st+=Integer.parseInt( Character.toString(ch[i]))*5;
k++;
}
else if (k%6==0) {
st+=Integer.parseInt( Character.toString(ch[i]))*1;
k++;
}
}
}

System.out.println(Long.parseLong(s)%7);//只用long验证下了
System.out.println(st%7);
}
}

[解决办法]
Integer的最大值是10位，那么可以9位9位的截取出来，求出余数，
然后求出 Math.pow(10,9)的余数，进行相乘
最后剩余位数不足9位，就再求一次Math.pow(10,n)的余数,然后和之前的余数相乘，加上尾数。
[解决办法]
哎 技不如人啊 想了好久
JScript codepublic class test {    /**     * 求一个由数字组成的任意长度的字符串能否被N整出     * @param args     */    public static void main(String[] args) {        // TODO Auto-generated method stub         String str = "54354358093245892583457839730957349857394857367935384895";            int n= 7;            int tmp = 0;            for(int i =0;i<str.length();i++){                tmp = (Integer.parseInt(str.charAt(i)+"")+tmp) % n;                System.out.println(tmp);            }            if(tmp == 0){                System.out.println("可以被整除");            }else{                System.out.println("当str加上"+(n-tmp)+"既可以被"+n+"整除");            }    }}
[解决办法]
一个三位以上的整数能否被7（11或13）整除，只须看这个数的末三位数字表示的三位数与末三位数字以前的数字所组成的数的差（以大减小）能否被7（11或13）整除。  

 另法：将一个多位数从后往前三位一组进行分段。奇数段各三位数之和与偶数段各三位数之和的差若被7（11或13）整除，则原多位数也被7（11或13）整除。  

 如3546725可分为3，546，725三段。奇数段的和为725＋3＝728，偶数段为546，二者的差为  

 728－546＝182＝7×26＝7×2×13

代码自己实现吧
[解决办法]
我这也有个方法，只写了个算出余数的方法，怎样加进去就不写了。
[code=Java][/code]
public class TT {

public static void main(String[] args) {
String str = "328493539952757478850238985656747746634635864599499999900";
int n = 7;
String rimainder = result(str,n);
System.out.println(rimainder);

}

public static String result(String str, int n) {
String[] sa = stringArray(str);
if(sa.length>1) {
int rimainder = Integer.valueOf(sa[0])%n;
String newstr = Integer.toString(rimainder);
sa[1] = newstr+sa[1];
return result(sa[1],n);
}
else return Integer.toString((Integer.valueOf(sa[0])%n));
}

private static String[] stringArray(String str) {
if(str.length()<10) {
String[] sa = {str};
return sa;
}
String[] sa = {str.substring(0, 9),str.substring(9, str.length())};
return sa;
}
}

[解决办法]
Java codepackage com.cn;public class Div7 {    public static void main(String[] args) {        String str = "7777777777777777777777777777777777777776";        char[] ch = new char[str.length()];        str.getChars(0,str.length(),ch,0);        String[] value = new String[str.length()];        int[]  n = new int[str.length()];                for (int i = 0; i < str.length(); i ++) {            value[i] = "" + ch[i];            n[i] = Integer.parseInt(value[i]);            System.out.print(n[i]);                    }        System.out.println("");        bet(n);                    }    /**     * 若一个整数的个位数字截去，再从余下的数中，减去个位数的2倍，如果差是7的倍数     * ，则原数能被7整除。如果差太大或心算不易看出是否7的倍数，就需要继续上述     * 「截尾、倍大、相减、验差」的过程，直到能清楚判断为止。例如，判断133是否7的     * 倍数的过程如下：13－3×2＝7，所以133是7的倍数；又例如判断6139是否7的倍数的     * 过程如下：613－9×2＝595 ， 59－5×2＝49，所以6139是7的倍数，余类推.     * @param n     */    private static void bet (int[] n) {        int m = n.length;        int b = 0;        int i =0;        for (i = 0;i < n.length - 3; i++) {            b = n[m -  4]*100 + n[m - 3]*10 + n[m -2];            System.out.println(b);            b = b - 2*n[m - 1];            n[m - 4] = b/100;            n[m - 3] = b%100/10;            n[m - 2] = b%10;            n[m - 1] = 0;            m--;            for (int j = 0;j < n.length; j ++) {                System.out.print(n[j]);            }            System.out.println("");        }                System.out.println(m + "m:b" + b);        if (3 == m) {            b = n[0]*100 + n[1]*10 + n[2];            if(b%7 == 0) {                System.out.println("yes!");            }            else {                System.out.println("no!");            }        }        else if (2 == m) {            b = n[0]*10 + n[1];            if(b%7 == 0) {                System.out.println("yes!");            }            else {                System.out.println("no!");            }        }        else if (1 ==m ) {            if(b%7 == 0) {                System.out.println("yes!");            }            else {                System.out.println("no!");            }        }    }}