Java 从右开始在正方形或矩形矩阵上添加对角线的算法

我想在正方形或矩形矩阵中添加对角线，以模拟在乘法算法中添加部分结果的过程

像这样：

     2412
   x 3231
---------
     2412
    7236
   4824
+ 7236
---------
  7793172

我需要一步一步地运行它，以满足在线法官程序的要求。我已经知道了如何得到乘法的部分结果（亨伯2412723648247236），我把它们放在了一个方阵上

我意识到，通过考虑正方形或矩形，我可以得到这个矩阵的加法结果：

2 4 1 2
7 2 3 6
4 8 2 4
7 2 3 6

通过将每个对角线相加（从右上角开始），并考虑加法的进位，并使用一个辅助数组来获得加法的结果，该辅助数组的位数与操作数a中的数字之和+操作数b中的数字之和相同（在本例中，操作数a为2412，操作数b为3231）

例如，最右侧的数组结果应为：

result[(digits_a+digits_b)-1] = partialResult[0][3]; 

下一步：

---

我一直在写双嵌套循环，应该从右上角开始添加这些对角线。救命啊。求你了

假设您的

部分结果

维度是

宽度

和

高度

，您可以通过以下两个循环进行添加（请参见操作中的内容）：

int位=宽度+高度-1；
整数进位=0；
对于（int d1=宽度-1；d1>=0；d1--）{
对于（int r=0；r

---

注意：进位可能在结果的结尾处为非空，这意味着结果中第一个数字之前的另一个数字。

假设您的

部分结果

尺寸为

宽度

和

高度

，您可以通过以下两个循环进行添加（请参见操作中的内容）：

int位=宽度+高度-1；
整数进位=0；
对于（int d1=宽度-1；d1>=0；d1--）{
对于（int r=0；r

注意：进位在结尾可能是非空的，这意味着结果中第一个数字之前还有另一个数字。

我最后使用了这个（不要问为什么它会将BigInteger转换为ArrayList，反之亦然，这是一个奇怪的家庭作业要求）

公共静态BigInteger simpleMultiply（BigInteger x，BigInteger y）抛出IOException{
龙胆草；
短角菌；
ArrayList multResult=新的ArrayList（2000）；
如果（x.compareTo（y）>=0）{//x是更长/相等的数值
longerNum=x.toString（）.toCharArray（）；
shorterNum=y.toString（）.toCharArray（）；
}
否则{//y是一个较长的num
longerNum=y.toString（）.toCharArray（）；
shorterNum=x.toString（）.toCharArray（）；
}
//shorter num等于部分结果中的行数
//longer num+1等于部分结果中的列数
int[][]partialResult=new int[shorterNum.length][longerNum.length+1]；
int=0；
int结果=0；
整数进位=0；
对于（int-sIndex=（shorterNum.length-1）；sIndex>=0；sIndex--）{
pastCarry=0；
对于（int-lIndex=（longerNum.length-1）；lIndex>=0；lIndex--）
{
int sInt=Integer.parseInt（“+shorterNum[sIndex]+”）；
int lInt=Integer.parseInt（“+longerNum[lIndex]+”）；
int product=sInt*lInt；
如果（lIndex==0）{
结果=（pastCarry+产品）%10；
进位=（进位+产品）/10；
进位=进位；
partialResult[sIndex][lIndex+1]=result；//partialResult中还有一个列元素
部分结果[sIndex][lIndex]=进位；
}
否则{
结果=（pastCarry+产品）%10；
进位=（进位+产品）/10；
进位=进位；
partialResult[sIndex][lIndex+1]=result；//partialResult中还有一个列元素
}
}
}
对于（int i=0；i我最终使用了这个（不要问为什么它会将BigInteger转换为ArrayList，反之亦然，这是一个奇怪的家庭作业要求）

公共静态BigInteger simpleMultiply（BigInteger x，BigInteger y）抛出IOException{
龙胆草；
短角菌；
ArrayList multResult=新的ArrayList（2000）；
如果（x.compareTo（y）>=0）{//x是更长/相等的数值
longerNum=x.toString（）.toCharArray（）；
shorterNum=y.toString（）.toCharArray（）；
}
否则{//y是一个较长的num
longerNum=y.toString（）.toCharArray（）；
shorterNum=x.toString（）.toCharArray（）；
}
//shorter num等于部分结果中的行数
//longer num+1等于部分结果中的列数
int[][]partialResult=new int[shorterNum.length][longerNum.length+1]；
int=0；
int结果=0；
整数进位=0；
对于（int-sIndex=（shorterNum.length-1）；sIndex>=0；sIndex--）{
pastCarry=0；
对于（int-lIndex=（longerNum.length-1）；lIndex>=0；lIndex--）
{
int sInt=Integer.parseInt（“+shorterNum[sIndex]+”）；
int lInt=Integer.parseInt（“+longerNum[lIndex]+”）；
int product=sInt*lInt；
如果（lIndex==0）{
结果=（pastCarry+产品）
result[digits_a+digits_b]=(partialResult[0][2] + partialResult[1][3] + carry) %10; 
newCarry = (partialResult[0][2] + partialResult[1][3] + carry) / 10; 

int digit = width + height - 1;
int carry = 0;

for (int d1 = width - 1; d1 >= 0; d1--) {
    for (int r = 0; r < height && d1 + r < width; r++)
        carry += partialResult[r][d1 + r];
    result[--digit] = carry % 10;
    carry /= 10;
}

for (int d2 = 1; d2 < height; d2++) {
    for (int c = 0; c < width && d2 + c < height; c++)
        carry += partialResult[d2 + c][c];
    result[--digit] = carry % 10;
    carry /= 10;
}

  public static BigInteger simpleMultiply(BigInteger x, BigInteger y) throws IOException {

        char [] longerNum;
        char [] shorterNum;


        ArrayList<Integer> multResult= new ArrayList<Integer>(2000);

        if(x.compareTo(y)>=0){ // x is a longer/equal num

            longerNum = x.toString().toCharArray();
            shorterNum = y.toString().toCharArray();

        }

       else { //y is a longer num

           longerNum = y.toString().toCharArray();
           shorterNum = x.toString().toCharArray();

       }


       //shorter num equals the number of rows in partial result
       // longer num + 1 equals the number of columns in partial result


        int [][] partialResult = new int [shorterNum.length][longerNum.length+1];

        int pastCarry=0;
        int result=0;
        int carry=0;

        for (int sIndex=(shorterNum.length-1); sIndex>=0; sIndex--){

            pastCarry=0;
            for (int lIndex = (longerNum.length-1); lIndex>=0; lIndex--)
            {
                int sInt = Integer.parseInt(""+shorterNum[sIndex]+"");
                int lInt = Integer.parseInt(""+longerNum[lIndex]+"");

                int product = sInt*lInt;

                if (lIndex==0){

                 result  =  (pastCarry+product)% 10;
                 carry   = (pastCarry+product) /  10;

                 pastCarry = carry;

                 partialResult [sIndex][lIndex+1] = result; //one more column element in partialResult

                 partialResult[sIndex][lIndex] = carry;


               }

                else {

                 result  = (pastCarry+product) % 10;
                 carry   = (pastCarry+product) /  10;

                 pastCarry = carry;

                 partialResult [sIndex][lIndex+1] = result;//one more column element in partialResult


                }

            }
        }
            for (int i=0; i<partialResult.length;i++)
                for (int j=0; j<partialResult[0].length;j++)
                {

                      System.out.print(partialResult[i][j] + " ");
                      if (j==partialResult[0].length-1){System.out.println();}
                }

        int auxColumn=0;
        int diagonalAcum=0;
        //add diagonals

        int copyDigit=0;
        int carryDigit=0;

        int lastCarry=0;



     rowCycle:
     for (int column=partialResult[0].length-1; column>=0; column--){

          diagonalAcum=0; //carryDigit=0;
          diagonalAcum+=carryDigit;
          auxColumn=column;

          for (int row=0; row<partialResult.length; row++){

              if (auxColumn+1 ==partialResult[0].length){

                  diagonalAcum+=partialResult[row][auxColumn++];

                   copyDigit=diagonalAcum % 10;
                   carryDigit=diagonalAcum / 10;

                   multResult.add(copyDigit);

                   continue rowCycle;

              }
              diagonalAcum+=partialResult[row][auxColumn++];
          } //end row cycle

          copyDigit= diagonalAcum % 10;
          carryDigit=diagonalAcum / 10;
          multResult.add(copyDigit);

          if(column==0){
              lastCarry = carryDigit;
          }
       }

     carryDigit=0; //reset

     int diagonal2Acum=0;
    // diagonal2Acum +=lastCarry;
    int auxRow;

    int diagCarry=0;

    int rowLimit=partialResult.length-1;
    int colLimit=partialResult[0].length-1;

    int initialRow=1;
    int colIndex=0;


    for (int row=initialRow;row<=rowLimit;row++){

        diagonal2Acum=0;
        diagonal2Acum +=lastCarry;
        lastCarry=0;

        auxRow = row;
        colIndex=0;

       // partialResult[auxRow][]
        while ((auxRow<=rowLimit) && (colIndex<=colLimit)){

           diagonal2Acum+= partialResult[auxRow++][colIndex++];


        }

        if ((colIndex==0)&&(row==rowLimit)) {

            copyDigit=(diagonal2Acum+carryDigit)%10;
            carryDigit=(diagonal2Acum+carryDigit)/10;

                multResult.add(copyDigit);
            multResult.add(carryDigit);


        }

        else {
        copyDigit=(diagonal2Acum+carryDigit)%10;
        carryDigit=(diagonal2Acum+carryDigit)/10;

        multResult.add(copyDigit);
        }


     } // end row for


     StringBuilder appended = new StringBuilder();

     for (int i=multResult.size()-1;i>=0;i--){

         appended.append(multResult.get(i));

     }

       System.out.println("result is " + appended.toString());

       BigInteger the_result1 = new BigInteger(appended.toString());
       return the_result1;
     }