Zahlenkreis Algorithmus

Sone

int const upper_limit = 30,
              lower_limit = 10,
              intervall_size = 20;

    int current = 15;

    current -= 24;

    if( current < 0 )
        current += intervall_size * ( (lower_limit - current) / intervall_size + 1 );

    current %= intervall_size;

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

Sone

Ach, er will Einzeiler! *sigh*

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

Sone

camper schrieb:

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:

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.

Sone

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$

Sone schrieb:

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.

Sone schrieb:

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.

Sone

Randbedingung übersehen, in der Tat - das macht es einfacher, und deinen Code korrekt.

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...

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

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!

volkard

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.

Sone

volkard schrieb:

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?

volkard schrieb:

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;
    }
}

volkard

adamsmith schrieb:

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.

volkard

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.

Sone

volkard schrieb:

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.

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?

Sone

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.

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.