La copia del código es la siguiente:
import java.io.bufferedReader;
import java.io.ioException;
import java.io.inputstreamreader;
import java.util.regex.matcher;
import java.util.regex.pattern;
/**
* La implementación simple de la multiplicación de grandes números aún no es muy perfecta
* Arreglar:
* 1. Algunos errores de eliminar 0 antes y después de la modificación
* 2. Apoye la operación de número negativo
* 3. Para determinar si la cadena de entrada cumple con la definición decimal, use expresiones regulares para juzgar
* @author icejoywoo
* @Since 2012.2.16
* @version 0.1.1
*/
clase pública Bignumber {
public static void main (string [] args) lanza ioexception {
System.out.println ("Ingrese dos enteros grandes:");
BufferedReader buffer = new BufferedReader (new InputStreamReader (System.in));
String [] strarray = buffer.readline (). Split ("//*");
System.out.println (bignumberMultiply (Strarray [0], Strarray [1]));
}
/**
* Calcule el producto de dos números de cualquier tamaño y precisión
* @param Primer primer parámetro
* @param segundo segundo parámetro
* @return multiplicar de dos números
*/
cadena estática privada bignumberMultiply (cadena primero, cadena en segundo) {
// signo de signo positivo y negativo
bandera booleana = falso;
if (first.charat (0) == '-') {
bandera =! Bandera;
Primero = Primero.substring (1);
}
if (segundo.charat (0) == '-') {
bandera =! Bandera;
segundo = segundo.substring (1);
}
// La posición del punto decimal
int apoints = first.length () - first.indexof ('.') - 1;
int bPoints = Second.Length () - Second.IndexOf ('.') - 1;
int Pointpos = apoints + bPoints;
// Eliminar el punto decimal
StringBuffer Abuffer = new StringBuffer (first.replaceall ("//.", ""));
StringBuffer bbuffer = new StringBuffer (segundo.replaceall ("//.", ""));
int [] a = String2IntaRay (abuffer.ToString ());
int [] b = String2InTarray (bbuffer.toString ());
int [] resultado = nuevo int [A.Length + B.Length - 1];
// calcular
para (int i = 0; i <a.length; i ++) {
para (int j = 0; j <b.length; j ++) {
resultado [i + j] + = a [i] * b [j];
}
}
// Si cierto en el resultado es mayor que 9, debe ser transportado.
for (int i = result.length -1; i> = 0; --i) {
if (resultado [i]> 9) {
resultado [i - 1] += resultado [i] / 10;
resultado [i] = resultado [i] % 10;
}
}
StringBuffer Buffer = new StringBuffer ();
para (int i = 0; i <result.length; ++ i) {
// Agregar puntos decimales
if (result.length - i == PointPos) {
buffer.append (".");
}
buffer.append (string.ValueOf (resultado [i]));
}
if (buffer.indexof (".")! = -1)
{
// Eliminar el primer 0
int i = 0;
while (i <buffer.length ()) {
if (buffer.length ()> 2 && buffer.charat (i+1) == '.') {// Solo hay un número 0 antes del punto decimal.
romper;
} else if (buffer.charat (i) == '0') {// Elimina el primer 0
buffer.deletecharat (i);
i = 0;
continuar;
} else {// cuando la primera posición no es 0
romper;
}
}
// Eliminar el final 0
i = buffer.length () - 1;
while (i> = 0) {
if (buffer.length ()> 2 && buffer.charat (i-1) == '.') {// El punto decimal es directamente un número
romper;
} else if (buffer.charat (i) == '0') {// Elimina el 0 al final
buffer.deletecharat (i);
i = buffer.length () - 1;
continuar;
} else {// Cuando el último bit no es 0
romper;
}
}
}
// Según el bit de signo, las banderas positivas y negativas del valor de retorno
if (flag) {
return "-" + buffer.ToString ();
} demás {
return buffer.ToString ();
}
}
/**
* Reemplace la cadena en una matriz
* @param número
* @devolver
*/
Private static int [] String2InTarray (número de cadena) {
// Determinar si la entrada cumple con los requisitos de los números de puntos flotantes
Pattern Pattern = Pattern.Compile ("^(-? // d+| // d*) //.?// d*$");
Matcher Matcher = Pattern.Matcher (número);
if (! Matcher.find ()) {
tirar nueva ilegalargumentException ("¡El número de entrada es incorrecto!");
}
int [] result = new int [number.length ()];
para (int i = 0; i <number.length (); i ++) {
resultado [i] = (int) (número.charat (i) - '0');
}
resultado de retorno;
}
}
Los resultados de la operación son los siguientes:
1. Juicio de entrada incorrecta
La copia del código es la siguiente:
Ingrese dos enteros grandes:
1A*A22
Excepción en el hilo "principal" java.lang.illegalargumentException: ¡el número de entrada es incorrecto!
en bignumber.string2intaRray (bignumber.java:132)
en bignumber.bignumberMultiply (bignumber.java:54)
en bignumber.main (bignumber.java:22)
2. Operación con números negativos, con 0 antes y después
La copia del código es la siguiente:
Ingrese dos enteros grandes:
-23424.2300*02345.234000000
-54935300.61982
Los resultados del cálculo en Python son los siguientes
La copia del código es la siguiente:
Python 2.6.5
>>> -23424.2300*02345.23400000
-54935300.619819999
Se puede ver que los resultados de Python están distorsionados