Zeichenreihenfolge umdrehen

[Esto88]

hey,

ich möchte die Alternierende Quersumme einer Zahl (zuvor als String übergeben; MUSS!) berechnen. Bspw. für
"87654321": 1 - 2 + 3 - 4 + 5 - 6 + 7 - 8 = -4

Mein bisheriger Versuch funktioniert so weit, allerdings mit falschen Vorzeichen, da er von der 8 aus anfängt. Kann ich auf eine einfache Weise Java anweisen den String anders einzulesen?

public class Prog {
        public static void main(String[] args) {

                int zahl1, zahl2, zahl3;
                int altquersumme1 = 0, altquersumme2 = 0, altquersumme3 = 0;
                int i = 1;
                        
                    System.out.println("Bitte geben Sie eine natuerliche Zahl ein:");
                    Scanner scan = new Scanner(System.in);
                    zahl1 = Integer.parseInt(scan.next());
                    scan.close();
   
                zahl2 = zahl1;
                zahl3 = zahl1;
                
                while (zahl1 > 0) {
                    if (i%2 == 0) {
                        altquersumme1 += zahl1%10;
                        altquersumme2 += zahl2%100;
                        altquersumme3 += zahl3%1000;
                        i++;
                    } else {
                        altquersumme1 -= zahl1%10;
                        altquersumme2 -= zahl2%100;
                        altquersumme3 -= zahl3%1000;
                        i++;
                    }
                    zahl1=zahl1/10;
                    zahl2=zahl2/100;
                    zahl3=zahl3/1000;
                }
                System.out.println("Alternierende Quersumme erster Stufe: \t" + altquersumme1);
                System.out.println("Alternierende Quersumme zweiter Stufe:\t" + altquersumme2);
                System.out.println("Alternierende Quersumme dritter Stufe:\t" + altquersumme3);
        }
     }

 

[rme]

Hm, deinen Ansatz finde ich recht aufwändig. Wäre es nicht einfach, die Zahl als String zu lassen, wenn du ihn eh so bekommst? Dann kannst du nämlich einfach eine for-Schleife verwenden und den String rückwärts durchgehen, dir die einzelnen Ziffern umwandeln und damit rechnen. Das umwandeln der Ziffern geht durch Subtraktion des Zeichens '0' recht einfach.

Wenn du bei deinem Ansatz bleiben willst: Dreh doch den String vor dem Umwandeln um, das geht z.B. mit der StringBuilder- oder StringBuffer-Klasse.

 

[anti-held]

Wie wäre es mit:

		String zahlen = "123456789";

		int quersumme = 0;

		for (int counter = 0; counter < zahlen.length(); counter++) {
			int currentNumber = zahlen.charAt(zahlen.length() - counter -1) - '0';
			quersumme += currentNumber * ((counter % 2 == 0) ? 1 : -1);
		}
		
		System.out.println("quersumme: " + quersumme);

Kurz geschrieben.

 

[Esto88]

@anti-held

Im Grunde schon, nur ist mir noch nicht klar, wie ich die da die alternierende Quersumme 2. und 3. Ordnung bekomme.



Scheinbar gelingt mir auch die richtige Anwendung der StringBuffer-Klasse nicht:

    public class Prog {

	public static void main(String[] args) {

		String zahlen = new StringBuffer(args[0]).reverse().toString();
		int zahl1 = Integer.parseInt(zahlen), zahl2, zahl3;
		int quersumme1 = 0, quersumme2 = 0, quersumme3 = 0;
		int altquersumme1 = 0, altquersumme2 = 0, altquersumme3 = 0;
		int i = 1;
	
		zahl2 = zahl1;
		zahl3 = zahl1;
		
		while (zahl1 > 0) {
			if (i%2 == 0) {
				altquersumme1 += zahl1%10;
			        altquersumme2 += zahl2%100;
				altquersumme3 += zahl3%1000;
				i++;
			} else {
				altquersumme1 -= zahl1%10;
			        altquersumme2 -= zahl2%100;
				altquersumme3 -= zahl3%1000;
				i++;
			}
		   quersumme1 += zahl1%10;
		   quersumme2 += zahl2%100;
		   quersumme3 += zahl3%1000;
		   zahl1=zahl1/10;
		   zahl2=zahl2/100;
		   zahl3=zahl3/1000;
		}

		System.out.println("Quersumme erster Stufe: \t\t" + quersumme1);
		System.out.println("Alternierende Quersumme erster Stufe: \t" + altquersumme1);
		System.out.println("Quersumme zweiter Stufe:\t\t" + quersumme2);
		System.out.println("Alternierende Quersumme zweiter Stufe:\t" + altquersumme2);
		System.out.println("Quersumme dritter Stufe:\t\t" + quersumme3);
		System.out.println("Alternierende Quersumme dritter Stufe:\t" + altquersumme3);
	}
}

Beim Übergeben des Wertes 123456789:

Raus kommt:
Quersumme erster Stufe: 45
Alternierende Quersumme erster Stufe: -5
Quersumme zweiter Stufe: 225
Alternierende Quersumme zweiter Stufe: 35
Quersumme dritter Stufe: 1962
Alternierende Quersumme dritter Stufe: -654

Raus kommen müsste:
Quersumme erster Stufe: 45
Alternierende Quersumme erster Stufe: 5
Quersumme zweiter Stufe: 225
Alternierende Quersumme zweiter Stufe: 45
Quersumme dritter Stufe: 1368
Alternierende Quersumme dritter Stufe: 456

 

[Esto88]

Niemand 'ne Idee woran es liegen kann?

 

[Tiding]

Hilft dir folgendes weiter?

	static int Quersumme(String z){
		z = new StringBuffer(z).reverse().toString();
		int z_ = Integer.parseInt(z);
		int Quersumme = 0;
		for(int i = 0; z_ > 0; i++){
			Quersumme += z_%10;
			z_ /= 10;
		}
		return Quersumme;
	}

 

[Tiding]

Damit könntest du all das bewerkstelligen, was du willst 😛opcorn:.

 

[Esto88]

konnt ich auch so, musste nur meine Variable i auf 0 setzen & das reverse rausnehmen 🙂

Dennoch danke, deinen Ansatz find ich sehr elegant; werd ich demnächst mal durchtesten 🙂

 

[Tiding]

Na, dann ist ja alles geklärt! :applaus:

 

[sindai]

Hey ich versteh nicht ganz wie das funktioniert, kann mir das mal einer erklären?

		while (zahl1 > 0) { // während mitgegebene Zahl größer 0 ...
			if (i%2 == 0) { // ... wenn Zahl durch 2 teilbar ist und keinen Rest hat
				altquersumme1 += zahl1%10; // +
			        altquersumme2 += zahl2%100;
				altquersumme3 += zahl3%1000;
				i++;
			} else {
				altquersumme1 -= zahl1%10; // oder -
			        altquersumme2 -= zahl2%100; // aber was bedeutet %10, %100, %1000 ?
				altquersumme3 -= zahl3%1000;
				i++;
			}
		   quersumme1 += zahl1%10;
		   quersumme2 += zahl2%100;
		   quersumme3 += zahl3%1000;
		   zahl1=zahl1/10;
		   zahl2=zahl2/100; // das vesteh ich auch nicht
		   zahl3=zahl3/1000;
		}

 

[sindai]

niemand?

 

[Tiding]

Und was genau verstehst du an dem Algorithmus nicht? ???:L

:noe:

geh es doch Schritt für Schritt im Kopf, z.b. nur für quersumme 1 durch!

 

[anti-held]

Hier eine Methode, die euch alle möglichen Quersummen berechnet:

	private static int quersumme(int stufe, boolean alternierend, String zahlen) {
		int quersumme = 0;
		StringBuilder sb = new StringBuilder();
		for (int counter = 0; counter <= zahlen.length() / stufe; counter++) {
			for (int currentNumber = 0; currentNumber < stufe; currentNumber++) {
				int index = zahlen.length() - stufe - stufe * counter + currentNumber;
				if (index >= 0 && index < zahlen.length()) {
					sb.append(zahlen.charAt(index));
				}
			}
			if (sb.length() > 0) {
				quersumme += Integer.parseInt(sb.toString()) * ((counter % 2 == 1 && alternierend) ? -1 : 1);
				// System.out.println(((counter % 2 == 1 && alternierend) ? '-'
				// : '+') + sb.toString() + " = " + quersumme);
			}
			sb = new StringBuilder();
		}
		return quersumme;
	}

bitte auch versuchen das zu verstehen.