求公共分母的一道趣题

https://www.codewars.com/kata/54d7660d2daf68c619000d95

原题↑

解题↓

import java.util.ArrayList;
public class Fracts {


  public static String convertFrac(long[][] lst) {
    long bigFrac = 1;
    long result = 1;
    int fracNum = 0;//原始分母数量
    int maxDLen = 0;
    ArrayList<long[]> divisor = new ArrayList();
    ArrayList<Long> members = new ArrayList<Long>();
    ArrayList<Long> fracs = new ArrayList<Long>();
    // lst是个long型的二维数组,里面的每组元素是分子和分母的组合形式
    // 获取其分母的公共分母,(分子也按需更改),返回三组数据的字符串形式
    for (int i = 0; i < lst.length; i++) {
      for (int j = 0; j < 2; j++) {
        if(j==1) { //开始获取分母
          //从上面if 开始进来了 所有的分母  多个数的最小公倍数求法:
          //是素数的保持素数,不是素数的分解
          long[] fracArray = new long[1];
          long[] fracArray2 = new long[1];
          int q;
          int lastIndex = 0;
          //分解质因数
          long frac = lst[i][j];//获取了每个二维数组的元素
          fracs.add(frac);
          int count = 0; //[计数]看看这个数有共几个质因数
          for(q=2;q<frac;q++) {
            
            if(frac%q==0) {
              //如果一个数能分解,就必定还有另一个因数,所以数组大小必须大于长度1
              //得到了这个质因数的值(多个,需要数组存放)
              //如果对每个数值的质因数,生成不同的数组或集合存放呢?
              count++;//有一个因数分解时,count就递增
              
              if(fracArray.length<=count) {
                fracArray = new long[count+1];//变更数组大小
                lastIndex=count;
                for(int h=0;h<fracArray2.length;h++) {
                  fracArray[h] = fracArray2[h];
                }
              }
              
              
              fracArray[count-1] = q; //将质因数添加到数组
              fracArray2 = fracArray;
              frac = frac/q;
              q=q/q;
                    
              
            }
            
          }
          //将最后的因数装入数组最后
          fracArray2[lastIndex] =q;
          if(count==0) {
            //这是个素数
            fracArray2[0]=frac;
          }
          
          divisor.add(fracArray2);
          if(fracArray2.length>maxDLen) {
            maxDLen = fracArray2.length;
          }
          
        }
        if(j==0) {
          long mem = lst[i][j];
          members.add(mem);
        }
      

      }

    }
    long[][] resultMatrixArr = new long[lst.length][maxDLen];
    long[][] resultMatrixArr2 = new long[maxDLen][lst.length];
    //将多个分母的分解的质因数装入二维数组,以最长质因数数组长度为二维矩阵宽度.原lst.length为高度.
    for(int l=0;l<lst.length;l++) {
      for(int p=0;p<divisor.get(l).length;p++) {
          resultMatrixArr[l][p]=divisor.get(l)[p];
      }
    }
    
    for(int aa=0;aa<lst.length;aa++) {//矩阵高
      int grow = 0;
      for(int cc=0;cc<maxDLen;cc++) {//矩阵宽
        //获取每行的unique的集合,去除每行存在的重复数字,保留唯一一个.
        long[] rowNum = resultMatrixArr[aa]; //0,0; 0,1; 0,2
        grow=cc;
        while((grow+1)<rowNum.length) {//如果cc+1不是最大数组下标 则+1
          grow++;
          if(rowNum[cc]==rowNum[grow]) {
            resultMatrixArr[aa][grow]=0;
          }
        }
        //将二维数组倒置装入另一个  
        resultMatrixArr2[cc][aa] = resultMatrixArr[aa][cc]; 
      }
    }
    

    for(int tt=0;tt<resultMatrixArr2.length;tt++) {//矩阵高
      for(int gg=0;gg<lst.length;gg++) {
        if(resultMatrixArr2[tt][gg]!=0) {
          result *= resultMatrixArr2[tt][gg];
        }
      }
      
    }
    
    String strResult = "";
    //获取分母的最小公倍数后
    for(int kk=0;kk<fracs.size();kk++) {
      if (result<fracs.get(kk)) {
        result=fracs.get(kk);
      }
    }
    for(int kk=0;kk<fracs.size();kk++) {
    
      strResult += "("+result/fracs.get(kk)*members.get(kk)+","+result+")";
    }
    return strResult;
  }

}