手写代码模块（Java实现）——笔试答题常用Model

手写代码模块（Java实现）——笔试答题常用Model

1.因式分解

Input：整数

Output：因数链表

    public static ArrayList<Integer> Factorization(int n) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        for (int i = 2; i <= Math.sqrt(n); i++) {
            if (n % i == 0) {
                list.add(i);
                if (n / i != i) {
                    list.add(n / i);
                }
            }
        }
        return list;
    }

2.GCD最大公约数求解

Input：整数q, 整数p

Output：GCD

public static GetGCD(int p, int q){
    if(q == 0)
        return p;
    int r = p % q;
    return GetGCD(q, r);//欧几里得算法digui
}

3.二分查找

a) while循环，非递归。

Input：有序数组， 查找关键数

Output：数在数组中的位置

    public static int BinarySearch(int[] arr,int key){
        int low = 0;
        int high = arr.length - 1;
        int middle = 0;

        if(key < arr[low] || key > arr[high] || low > high){
            return -1;
        }

        while(low <= high){
            middle = (low + high) / 2;
            if(arr[middle] > key){
                high = middle - 1;
            }else if(arr[middle] < key){
                low = middle + 1;
            }else{
                return middle;
            }
        }

        return -1;		//not found, return -1.
    }

b) 递归实现。

Input：有序数组， 查找关键数，查找范围上界，查找范围下界

Output：数在数组中的位置

    public static int recursionBinarySearch(int[] arr,int key,int low,int high){
        // out of range, not found 
        if(key < arr[low] || key > arr[high] || low > high){
            return -1;
        }

        int mid = (low + high) / 2;
        if(arr[mid] > key){
            return recursionBinarySearch(arr, key, low, mid - 1);
        }else if(arr[mid] < key){
            return recursionBinarySearch(arr, key, mid + 1, high);
        }else {
            return mid;
        }

    }

4.大数加法

Input：大数a， 大数b

Output：和 or 积

使用BigInteger类

public static void main(String[] args) {

  String a="8888899999999888";
  String b="88888888888888";
  String str=new BigInteger(a).add(new BigInteger(b)).toString();
  System.out.println(str);
  
 }

字符串模拟

1.反转两个字符串，便于从低位到高位相加和最高位的进位导致和的位数增加；

2.对齐两个字符串，即短字符串的高位用‘0’补齐，便于后面的相加；

3.把两个正整数相加，一位一位的加并加上进位。

/**
     * 用字符串模拟两个大数相加
     * @param n1 加数1
     * @param n2 加数2
     * @return   相加结果
     */
    public static String add2(String n1,String n2)
    {
        StringBuffer result = new StringBuffer();
    
        //1、反转字符串
        n1 = new StringBuffer(n1).reverse().toString();    
        n2 = new StringBuffer(n2).reverse().toString();
        
        int len1 = n1.length();
        int len2 = n1.length();
        int maxLen = len1 > len2 ? len1 : len2;
        boolean nOverFlow = false; //是否越界
        int nTakeOver = 0 ; //溢出数量
        
        //2.把两个字符串补齐，即短字符串的高位用0补齐
        if(len1 < len2)
        {
            for(int i = len1 ; i < len2 ; i++)
            {
            n1 += "0";
            }
        }
        else if (len1 > len2)
        {
            for(int i = len2 ; i < len1 ; i++)
            {
            n2 += "0";
            }
        }
        
        //3.把两个正整数相加，一位一位的加并加上进位
        for(int i = 0 ; i < maxLen ; i++)
        {
            int nSum = Integer.parseInt(n1.charAt(i) +"") + Integer.parseInt(n2.charAt(i) +"");
            
            if(nSum >= 10)
            {
            if(i == (maxLen - 1))
            {
                nOverFlow  = true;
            }
            nTakeOver = 1;
            result.append(nSum - 10);
            }
            else
            {
            nTakeOver = 0;
            result.append(nSum);
            }
        }
        
        //如果溢出的话表示位增加了
        if(nOverFlow)
        {
            result.append(nTakeOver);
        }
        return result.reverse().toString();
    }

5.大数乘法法

Input：大数a， 大数b

Output：积

mport java.util.Scanner;

/**
 * 大数相乘
 * @author Ant
 *
 */
public class BigMultiply {

    /**
     * 大数相乘基本思想，输入字符串，转成char数组，转成int数组。采用分治思想，每一位的相乘;<br>
     * 公式：AB*CD = AC (BC+AD) BD , 然后从后到前满十进位(BD,(BC+AD),AC)。
     * @param num1
     * @param num2
     */
    public String multiply(String num1, String num2){
        //把字符串转换成char数组
        char chars1[] = num1.toCharArray();
        char chars2[] = num2.toCharArray();

        //声明存放结果和两个乘积的容器
        int result[] = new int[chars1.length + chars2.length];
        int n1[] = new int[chars1.length];
        int n2[] = new int[chars2.length];

        //把char转换成int数组，为什么要减去一个'0'呢？因为要减去0的ascii码得到的就是实际的数字
        for(int i = 0; i < chars1.length;i++)
            n1[i] = chars1[i]-'0';
        for(int i = 0; i < chars2.length;i++)
            n2[i] = chars2[i]-'0';

        //逐个相乘，因为你会发现。AB*CD = AC(BC+AD)BD , 然后进位。
        for(int i =0 ; i < chars1.length; i++){
            for(int j =0; j < chars2.length; j++){
                result[i+j]+=n1[i]*n2[j];
            }
        }

        //满10进位，从后往前满十进位
        for(int i =result.length-1; i > 0 ;i--){
            result[i-1] += result[i] / 10;
            result[i] = result[i] % 10;
        }

        //转成string并返回
        String resultStr = "";
        for(int i = 0; i < result.length-1; i++){
            resultStr+=""+result[i];
        }
        return resultStr;
    }

    public static void main(String[] args) {
        BigMultiply bm = new BigMultiply();
        System.out.println("-----输入两个大数------");
        Scanner scanner = new Scanner(System.in);
        String num1 = scanner.next();
        String num2 = scanner.next();
        String result = bm.multiply(num1, num2);
        System.out.println("相乘结果为："+result);
        scanner.close();
    }
}