Java: Quersumme und alternierende Quer

[Rootster]

Schönen Guten Tag

Ich stehe vor folgendem Problem und hoffe, dass ihr mir dabei vielleicht helfen könnt, bzw. mir einen Tipp geben könntet.
Ich bin gerade dabei ein Programm zu schreiben, welches die 1. - 3. Stufe der Quersumme und die 1.-3. Stufe der alternierenden Quersumme berechnet

Es wird eine beliebig lange Zahlenreihe(x) eingegeben:
Quersumme 1. Stufe. x(abcdefg) = a+b+c+d+e+f+g =
Quersumme 2. Stufe. x(abcdefg) = ab+cd+ef+g =

alternierende Quersume 1. Stufe. x(abcdefg) = a-b+c-d+e-f+g =
alternierende Quesrumme 2. Stufe x(abcdefg) = ab-cd+ef-g =

Also die Quersumme 1. Stufe war bei mir überhaupt kein Problem, hier mein Ergebnis:

 public static long normalQuersumme(long n) {
		long querSumme = 0;
		while (n != 0) {
	    querSumme = querSumme + n % 10;
	    n /= 10;
	    }
	return querSumme;
	}

Allerdings habe ich probleme mit der 2. Stufe und den alternierenden Quersummen, mein Hauptproblem liegt darin, dass ich nicht weiß wie ich am besten mit den Eingegebenen Werten weiterarbeiten soll. Da es eine beliebig lange Zahlenreihe sein kann, kann ich leider keinen Array vorfertigen und mit einfachen Rechenregeln wie (a-b+c-d+e-f+g) weiterarbeiten, aus dem Grund weil ich ja nicht weiß ob (abc) oder doch vielleicht (abcdefghi) eingegeben wird.

Ich habe schon versucht die Zahlen einzeln voneinander zu trennen,

for (i=0; i < stellen; i++) { 
			z = n % 10;
			n = (n-z) / 10;

Somit hätte ich die letzte Stelle der Eingegebenen Zahlen, zuerst wollte ich das für jede Stelle allerdings kommt mir das wirklich sehr sehr umständlich vor, genau aus dem Grund hoffe ich auf eure Hilfe

Ich hoffe ihr könnt mir bei diesem Problem weiterhelfen,
Ich danke euch schonmal !

Mfg rootster

 

[GrafZahl]

aaaalso ... du hast eine eingabe die aus geordneten zeichen besteht ...

diese willst du nun für die "stufe" x in tupel der länge x aufsplitten

danach möchtest du diese tupel in zahlen wandeln

und entsprechend einer regel entweder addieren oder subtrahieren

die reihenfolge dieser schritte ist nur bedingt festgelegt

du könntest z.b. eine art zeiger benutzen der vom start der eingabezeichenfolge auf das gerade zu verarbeitende tupel zeigt, und diesen zeiger mit einer schrittweite x hochzählen bis du die eingabe verarbeitet hast, und je ein tupel aus der eingabe extrahieren und verarbeiten...

für die verarbeitung eines tupels ließt du die tupel länge ab der durch den zeiger markierten stelle aus der eingabe zeichenfolge. ggf. sollte man darauf achten dass die eingabe nicht unbedingt glatt in tupel aufteilbar ist, und das letzte tupel kürzer ist als die anderen.

die regel mit der du ein tupel entweder zur gesammtsumme addierst oder subtrahierst, kann man evtl als sich wiederholende liste von operatoren werten. eine solche liste hätte einen index, anhand dessen man einzelne operatoren selektieren kann. Auch diesen index kann man wiederum als zeiger verwenden und sich so entsprechend merken welche operator gerade verwendet werden soll


und wenn das noch nicht genug gewinke mit dem zaunpfahl war...

Spoiler: ...dann winkt hier der ganze gartenzaun

using System;
using System.Linq;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string input = Console.ReadLine();
            Console.WriteLine(komischeQueersumme(input, 1, '+'));
            Console.WriteLine(komischeQueersumme(input, 2, '+'));
            Console.WriteLine(komischeQueersumme(input, 1, '+', '-'));
            Console.WriteLine(komischeQueersumme(input, 2, '+', '-'));
            System.Threading.Thread.Sleep(5000);
        }

        static int komischeQueersumme(string input, int stufe, params char[] operanden) 
        {
            int ret = 0;
            int tmp = 0;
            int curOp = 0;
            int curOffset = 0;
            
            if (operanden.Any(x => x != '+' && x != '-') || stufe<1)
                throw new ArgumentException();

            if (!int.TryParse(input.Substring(0, Math.Min(stufe, input.Length)), out tmp))
                throw new ArgumentException();
            ret = tmp;
            curOffset += stufe;
            while (curOffset < input.Length)
            {
                if (!int.TryParse(input.Substring(curOffset, Math.Min(stufe,input.Length-curOffset)), out tmp))
                    throw new ArgumentException();
                switch (operanden[curOp++ % operanden.Length])
                {
                    case '+':
                        ret += tmp;
                        break;
                    case '-':
                        ret -= tmp;
                        break;
                    default:
                        throw new ImpossiburuException();
                }
                curOffset += stufe;
            }
            return ret;
        }
    }

    [Serializable]
    public class ImpossiburuException : Exception
    {
        public ImpossiburuException() { }
        public ImpossiburuException(string message) : base(message) { }
        public ImpossiburuException(string message, Exception inner) : base(message, inner) { }
        protected ImpossiburuException(
          System.Runtime.Serialization.SerializationInfo info,
          System.Runtime.Serialization.StreamingContext context)
            : base(info, context) { }
    }
}