algoritmo para agregar las diagonales en una matriz cuadrada o rectangular, comenzando hacia la derecha

Quiero agregar las diagonales en una matriz cuadrada o rectangular para emular el proceso de agregar los resultados parciales en un algoritmo de multiplicación.

Me gusta esto:

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

Necesito ejecutar esto, paso a paso, para satisfacer los requisitos de un programa de jueces en línea. Ya he descubierto cómo obtener los resultados parciales de las multiplicaciones (los números 2412, 7236, 4824, 7236) y los he colocado en una matriz cuadrada.

Me di cuenta de que puedo obtener el resultado de la suma de esta matriz considerando cuadrado o rectangular como:

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

y obtenga el resultado de la suma agregando cada diagonal (comenzando con la superior derecha) y teniendo en cuenta el acarreo de la suma y usando una matriz auxiliar que tenga el mismo número de dígitos que number_of_digits_in_operand_a + number_of_digits_in_operand_b (operando un ser 2412 y el operando b es 3231, en este caso).

Por ejemplo, el resultado de la matriz, en su posición más a la derecha, debería ser:

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

siguiente:

result[digits_a+digits_b]=(partialResult[0][2] + partialResult[1][3] + carry) %10; 
newCarry = (partialResult[0][2] + partialResult[1][3] + carry) / 10; 

Bueno, estoy atascado escribiendo el bucle anidado doble que se supone que agrega estas diagonales comenzando con el superior derecho. Ayuda. Por favor.

Respuesta 1

Terminé usando esto (no pregunte por qué convierte un BigInteger en una ArrayList y viceversa, es un requisito de tarea extraño).

  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;
     }
Respuesta: 2

Estoy diseñando una aplicación web donde quiero usar el máximo de etiquetas de struts en la página JSP en lugar de código java. En mi caso, una de las acciones es tomar datos de un JSP >> obtener datos de db según ...

Saludos, estoy escribiendo una aplicación que utilizará un servicio que debe iniciarse antes de que cualquier otro servicio que escuche la transmisión BOOT_COMPLETED pueda comenzar. Después de algo superficial ...

Me he encontrado con un problema muy extraño en Eclipse, y no estoy seguro de si es un error o si algunas configuraciones son incorrectas. Estoy usando Fedora Eclipse en Fedora 14. Noté este problema por primera vez al abrir un ...

Necesito ser capaz de lograr dos tareas de subprocesamiento en un contenedor y necesito comprender las mejores prácticas para hacerlo. Estas son las dos clases de tareas que necesito realizar: Durante un servicio web ...