Quersumme berechnen (BigInteger)

[Guest]

Hi,

würde gerne von einer großen Zahl, beispielsweise 7635527627 die Quersumme berechnen und zwar möglichst effizient da ich das für sehr viele Zahlen machen möchte.

Nur wie stelle ich das effizient an? Die ineffiziente Variante wäre diese:

	     String z = bigint.toString();
		int[] d = new int[10];
		d[0] = Integer.parseInt(z.substring(0, 1));
		d[1] = Integer.parseInt(z.substring(1, 2));
		d[2] = Integer.parseInt(z.substring(2, 3));
		d[3] = Integer.parseInt(z.substring(3, 4));
		d[4] = Integer.parseInt(z.substring(4, 5));
		d[5] = Integer.parseInt(z.substring(5, 6));
		d[6] = Integer.parseInt(z.substring(6, 7));
		d[7] = Integer.parseInt(z.substring(7, 8));
		d[8] = Integer.parseInt(z.substring(8, 9));
		d[9] = Integer.parseInt(z.substring(9, 10));
int summe = d[0] + d[1] + ...;

 

[SlaterB]

hol dir das char-Array des Strings und wandle jeden char in die richtige Ziffer um (minus '0')

 

[Gast]

Naja, die zeitintensive Operation ist ja gerade dieses toString();
Das würde ich gerne vermeiden.

 

[SlaterB]

tja, etwa 10x so schnell (nach kurzem Test) scheint die Operation toByteArray() zu sein,
dann muss man aber die Bytes mühsam wieder nach Int zurückrechnen mit Übertrag usw.,
eigentlich hat man dafür ja BigInteger

intern scheinen die Zahlen schön passend in einem int[] mag abgelegt zu sein, es gibt z.B. die private Operation

    /**
     * Returns the specified int of the little-endian two's complement
     * representation (int 0 is the least significant).  The int number can
     * be arbitrarily high (values are logically preceded by infinitely many
     * sign ints).
     */
    private int getInt(int n) {
        if (n < 0)
            return 0;
	if (n >= mag.length)
	    return signInt();

	int magInt = mag[mag.length-n-1];

	return (int) (signum >= 0 ? magInt :
		       (n <= firstNonzeroIntNum() ? -magInt : ~magInt));
    }

aber public ist die nunmal nicht,


ich kann leider auf die Schnelle auch sonst nix sehen um an mag oder eine Kopie davon zu kommen

von Reflection mal abgesehen, was dann vielleicht auch wieder langsam ist ungeachtet der Unschönheit