ich suche einen möglichst kurzen Algorithmus für einen Zahlenkreis.

Z.B. 1-20 (ohne 0)

Stand ist 5. Die Eingabe von +9 wäre dann 14, bei -9 wäre es 16.

a, b, c und d sind frei wählbar, wobei für die Menge (M) a <= b gilt und c ∈ M ist. d ist völlig frei wählbar und kann auch -1333 oder 546 sein.

Ich suche im Moment einen Einzeiler. In mehreren Zeilen ist es kein Problem.

a=1
b=20
c=5
d=9

a, b, c und d sind frei wählbar, wobei für die Menge (M) a <= b gilt und c ∈ M ist. d ist völlig frei wählbar und kann auch -1333 oder 546 sein.

Ich suche im Moment einen Einzeiler. In mehreren Zeilen ist es kein Problem.

Dein Deutsch verstehe ich nicht.

Zeig den Mehrzeiler als C++-Code. Das ist dann eine eindeutige Anfrage.
Falls die Variablen Einschränkungen im Wertebereich haben, schreibe sich auch dazu.

Kannst du natürlich entsprechend abkürzen wenn die untere Intervallgrenze nur 0 ist.

Edit: Volkard, kannst gerne raus editieren falls das jetzt nicht nötig war.

((a-2+c+d)%(b-a+1)+b-a+1)%(b-a+1)+1

äh, das letzte +1 sollte +a sein. ((a-2+c+d)%(b-a+1)+b-a+1)%(b-a+1)+a

foo % -20 ?

Jetzt habe ich dich. Abgesehen von dem Fragezeichen.
C++ verwendet die symmetrische Variante des Modulo-Operators:
$a ~mod~ m = a - m * ( sgn(a)sgn(m) \lfloor \frac{|a|}{|m|} \rfloor )$

Sind also sowohl a (-4) als auch m (hier -20) negativ, ergibt sich
$a ~mod~ m = a - m * ( \lfloor \frac{a}{m} \rfloor )$
Allerdings kann a wie in diesem Beispiel kleiner sein als m, daher kann es passieren dass $\lfloor \frac{a}{m} \rfloor ~=~ 0$ wird.
Damit ist das Ergebnis a (-4) - was aber nicht stimmen kann.

meinzeiler schrieb:

((a-2+c+d)%(b-a+1)+b-a+1)%(b-a+1)+1

äh, das letzte +1 sollte +a sein. ((a-2+c+d)%(b-a+1)+b-a+1)%(b-a+1)+a

Der Preis scheint auf den ersten Blick an meinzeiler zu gehen.

Der Algo scheint zu stimmen.

meinzeiler schrieb:

((a-2+c+d)%(b-a+1)+b-a+1)%(b-a+1)+1

äh, das letzte +1 sollte +a sein. ((a-2+c+d)%(b-a+1)+b-a+1)%(b-a+1)+a

Lol! Dein Algorithmus erzeugt zweimal undefiniertes Verhalten für $a = b + 1$

meinzeiler schrieb:

meinzeiler schrieb:

((a-2+c+d)%(b-a+1)+b-a+1)%(b-a+1)+1

äh, das letzte +1 sollte +a sein. ((a-2+c+d)%(b-a+1)+b-a+1)%(b-a+1)+a

Lol! Dein Algorithmus erzeugt zweimal undefiniertes Verhalten für $a = b + 1$

Eine von mir getätigte Randbedingung war ab, dass a <= b sein muss. Deshalb kann a nicht b+1 sein.

meinzeiler schrieb:

meinzeiler schrieb:

((a-2+c+d)%(b-a+1)+b-a+1)%(b-a+1)+1

äh, das letzte +1 sollte +a sein. ((a-2+c+d)%(b-a+1)+b-a+1)%(b-a+1)+a

Lol! Dein Algorithmus erzeugt zweimal undefiniertes Verhalten für $a = b + 1$

Bitte zuerst die Aufgabenstellung lesen bevor du antwortest.

adamsmith schrieb:

wobei für die Menge (M) a <= b gilt und c ∈ M ist.

Und erklär mir bitte mal, was "zweimal undefiniertes Verhalten" bedeutet.

meinzeiler schrieb:

Und erklär mir bitte mal, was "zweimal undefiniertes Verhalten" bedeutet.

Damit meinte ich, dass an zwei Stellen undefiniertes Verhalten erzeugt wird. Natürlich ist es aber in Wirklichkeit nur einmal, da schon nach dem ersten mal das ganze Ergebnis undefiniert wird.

Ich dachte übrigens auch, a und b sind nicht die Intervallgrenzen sondern...

Console.WriteLine(Circle(1, 20, 5, 9));     // 14
Console.WriteLine(Circle(1, 20, 5, -9));    // 16
Console.WriteLine(Circle(1, 20, 5, -5));    // 20
Console.WriteLine(Circle(1, 20, 1, 0));     // 1
Console.WriteLine(Circle(1, 20, 1, 20));    // 1
Console.WriteLine(Circle(1, 20, 1, 19));    // 20
Console.WriteLine(Circle(1, 20, 18, 19));   // 17
Console.WriteLine(Circle(1, 20, 20, 1));    // 1
Console.WriteLine(Circle(1, 20, 20, -1));   // 19
Console.WriteLine(Circle(1, 20, 1, -2));    // 19
Console.WriteLine(Circle(1, 20, 2, -2));    // 20
Console.WriteLine(Circle(1, 20, 1, 44));    // 5
Console.WriteLine(Circle(1, 20, 1, -38));   // 3

Danke!

Ich habe den Einzeiler von meinzeiler jetzt schnell noch einmal durchgetestet und er liefert exakt dieselben werde, wie mein Mehrzeiler mit if-else-Bedingung.

Aber er ist langsamer und schlechter lesbar.

adamsmith schrieb:

Ich habe den Einzeiler von meinzeiler jetzt schnell noch einmal durchgetestet und er liefert exakt dieselben werde, wie mein Mehrzeiler mit if-else-Bedingung.

Aber er ist langsamer und schlechter lesbar.

Ich dachte, das wäre jetzt eine Spaßaufgabe - du willst das tatsächlich in deiner Anwendung hinschreiben?

adamsmith schrieb:

Ich habe den Einzeiler von meinzeiler jetzt schnell noch einmal durchgetestet und er liefert exakt dieselben werde, wie mein Mehrzeiler mit if-else-Bedingung.

Aber er ist langsamer und schlechter lesbar.

Schlechter lesbar, ja. Aber auch langsamer?

Hier übrigens der Mehrzeiler von mir.

int Circle(int a, int b, int c, int d)
{
    int x = (c + d) % b;

    if(x == 0)
    {
        return b;
    }
    else if(x > b)
    {
        return x - b;
    }
    else if(x < 0)
    {
        return b + x;
    }
    else
    {
        return x;
    }
}

Hier übrigens der Mehrzeiler von mir.

int Circle(int a, int b, int c, int d)
{
    int x = (c + d) % b;

    if(x == 0)
    {
        return b;
    }
    else if(x > b)
    {
        return x - b;
    }
    else if(x < 0)
    {
        return b + x;
    }
    else
    {
        return x;
    }
}

Das ist mal ne gute Grundlage.
Danke.

Ich dachte, das wäre jetzt eine Spaßaufgabe - du willst das tatsächlich in deiner Anwendung hinschreiben?

Du Nube sollst noch bescheiden und hilfreich sein. Bitte bitte.

Sone schrieb:

Ich dachte, das wäre jetzt eine Spaßaufgabe - du willst das tatsächlich in deiner Anwendung hinschreiben?

Du Nube sollst noch bescheiden und hilfreich sein. Bitte bitte.

Ok ok.

C++ verwendet die symmetrische Variante des Modulo-Operators:
$a ~mod~ m = a - m * ( sgn(a)sgn(m) \lfloor \frac{|a|}{|m|} \rfloor )$

Sind also sowohl a (-4) als auch m (hier -20) negativ, ergibt sich
$a ~mod~ m = a - m * ( \lfloor \frac{a}{m} \rfloor )$
Allerdings kann a wie in diesem Beispiel kleiner sein als m, daher kann es passieren dass $\lfloor \frac{a}{m} \rfloor ~=~ 0$ wird.
Damit ist das Ergebnis a (-4) - was aber nicht stimmen kann.

Wieso kann das nicht stimmen? Wo siehst du hier ein Problem?

Sone schrieb:

C++ verwendet die symmetrische Variante des Modulo-Operators:
$a ~mod~ m = a - m * ( sgn(a)sgn(m) \lfloor \frac{|a|}{|m|} \rfloor )$

Sind also sowohl a (-4) als auch m (hier -20) negativ, ergibt sich
$a ~mod~ m = a - m * ( \lfloor \frac{a}{m} \rfloor )$
Allerdings kann a wie in diesem Beispiel kleiner sein als m, daher kann es passieren dass $\lfloor \frac{a}{m} \rfloor ~=~ 0$ wird.
Damit ist das Ergebnis a (-4) - was aber nicht stimmen kann.

Wieso kann das nicht stimmen? Wo siehst du hier ein Problem?

Das Ergebnis sollte wieder im Bereich 1, 20 sein.

out schrieb:

Sone schrieb:

C++ verwendet die symmetrische Variante des Modulo-Operators:
$a ~mod~ m = a - m * ( sgn(a)sgn(m) \lfloor \frac{|a|}{|m|} \rfloor )$

Sind also sowohl a (-4) als auch m (hier -20) negativ, ergibt sich
$a ~mod~ m = a - m * ( \lfloor \frac{a}{m} \rfloor )$
Allerdings kann a wie in diesem Beispiel kleiner sein als m, daher kann es passieren dass $\lfloor \frac{a}{m} \rfloor ~=~ 0$ wird.
Damit ist das Ergebnis a (-4) - was aber nicht stimmen kann.

Wieso kann das nicht stimmen? Wo siehst du hier ein Problem?

Das Ergebnis sollte wieder im Bereich 1, 20 sein.

Ne. Ich habe in der Schule gelernt, dass es 2 "Modulo" gibt. Das mathematische (das du meinst) und das informationstechnische.

Das mathematisches Modulo:
1. Kenn nur einen positiven Rest. Der ganzzahlige Rest muss also positiv sein.
2. a%b Das Ergebnis wiederholt sich alle b Mal:

a:      -9 -8 -7 -6 -5 -4 -3 -2 -1  0  1  2  3  4  5  6  7  8  9
          ----------------------------------------------------------------
          mod b:   3  0  1  2  3  0  1  2  3  0  1  2  3  0  1  2  3  0  1

Du kannst also ein Vielfaches von b dazuaddieren, falls a negativ ist: a%b = (a+i*b)%b

Das informationstechnische Modulo:
1. Der ganzzahlige Rest kann positiv oder negativ sein.
2. a%b Wenn a positiv ist, ist das Ergebnis auch positiv. Wenn a negativ ist, ist das Ergebnis auch negativ. Ergo, das Vorzeichen von b ist egal.

So hab ich das mal gelernt.

Sone schrieb:

out schrieb:

Sone schrieb:

C++ verwendet die symmetrische Variante des Modulo-Operators:
$a ~mod~ m = a - m * ( sgn(a)sgn(m) \lfloor \frac{|a|}{|m|} \rfloor )$

Sind also sowohl a (-4) als auch m (hier -20) negativ, ergibt sich
$a ~mod~ m = a - m * ( \lfloor \frac{a}{m} \rfloor )$
Allerdings kann a wie in diesem Beispiel kleiner sein als m, daher kann es passieren dass $\lfloor \frac{a}{m} \rfloor ~=~ 0$ wird.
Damit ist das Ergebnis a (-4) - was aber nicht stimmen kann.

Wieso kann das nicht stimmen? Wo siehst du hier ein Problem?

Das Ergebnis sollte wieder im Bereich 1, 20 sein.

Ne. Ich habe in der Schule gelernt, dass es 2 "Modulo" gibt. Das mathematische (das du meinst) und das informationstechnische.

Das mathematisches Modulo:
1. Kenn nur einen positiven Rest. Der ganzzahlige Rest muss also positiv sein.
2. a%b Das Ergebnis wiederholt sich alle b Mal:

a:      -9 -8 -7 -6 -5 -4 -3 -2 -1  0  1  2  3  4  5  6  7  8  9
          ----------------------------------------------------------------
          mod b:   3  0  1  2  3  0  1  2  3  0  1  2  3  0  1  2  3  0  1

Du kannst also ein Vielfaches von b dazuaddieren, falls a negativ ist: a%b = (a+i*b)%b

Das informationstechnische Modulo:
1. Der ganzzahlige Rest kann positiv oder negativ sein.
2. a%b Wenn a positiv ist, ist das Ergebnis auch positiv. Wenn a negativ ist, ist das Ergebnis auch negativ. Ergo, das Vorzeichen von b ist egal.

So hab ich das mal gelernt.

War es nicht so, daß in C++ dem Compiler freigestellt ist, ob er das mathematische oder das informationstechnische benutzt?