添加固定的最小/最大值

Question

主要編輯：100％解決！ 它被稱為模塊化算術感謝彼得！

我需要添加兩個具有固定最小/最大值的數字。 我希望我的數字表現得像java的int / byte / short（溢出到其相反的值並繼續操作）

System.out.println((byte) (Byte.MAX_VALUE));    // 127
System.out.println((byte)(Byte.MAX_VALUE + 1)); // -128
System.out.println((byte)(Byte.MAX_VALUE + 2)); // -127
System.out.println((byte)(Byte.MAX_VALUE + 3)); // -126

但具有固定的.MAX_VALUE和.MIN_VALUE。 如果一個數字的值是3並且它的maxValue是5並且minValue是2，那么當我向它添加4時（3 + 4 =應該是7）它溢出所以3 + 4：3 - > 4 - > 5 - > 2 - > 3示例：

    int value = 0, minValue = -2, maxValue = 1;
    MyNumber n = new MyNumber(value, minValue, maxValue);

    // possible values: -2 -1  0  1 -2 -1  0  1 -2 -1  0  1 ..

    n.add(2);   // 0+2 = -2
    n.add(-2);  // -2-2 = 0
    n.add(5);   // 0+5 = 1       
    n.add(-5);  // 1-5 = 0       
    n.add(-5);  // 0-5 = -1       
    n.add(-1);  // -1-1 = -2       
    n.add(11);  // -2+11 = 1

這就是我做的：

class MyNumber {

    int value;
    final int minValue, maxValue;

    public MyNumber(int value, int minValue, int maxValue) {
        if (value < minValue || value > maxValue || maxValue < minValue) {
            throw new RuntimeException();
        }
        this.value = value;
        this.minValue = minValue;
        this.maxValue = maxValue;
    }

    void add(int amount) {
        int step = 1;
        if (amount < 0) {
            step = -1;
            amount = -amount;
        }
        while (amount-- > 0) {
            value += step;
            if (value < minValue)
                value = maxValue; // overflows
            if (value > maxValue)
                value = minValue; // overflows
        }
    }
}

它有效，但我不想迭代整個添加，因為我將使用大數字我認為它與MOD有關...（我在數學上很糟糕）幾乎隨機我做了這個：

void add(int amount) {
    value = (value + amount) % (maxValue - minValue + 1);
}

我是如此接近，但它失敗了

n = new MyNumber(-2, -4, -1);
n.add(2); // -2+2 shows 0 instead of -4   (-2.. -1.. *overflow*.. -4)

我投降

Answer 1

我會盡量讓事情變得清晰。 例如

如果你想要時鍾算術，你可以做

   // in the constructor
   this.range = maxValue - minValue + 1;
   this.value = -minValue;

   // in the adder.
   public void add(int num) {
       value = (value + num) % range;
       if(value < 0) value += range;
       // or
       value = ((value + num) % range + range) % range;
   }


   // add a getter for value.
   public int getValue() { return value + minValue; };

---

如果你想要有界算術。

    value = Math.min(maxValue, Math.max(minValue, value + step));

Answer 2

嘗試

value += amount;

value = value > maxValue ? maxValue : value < minValue ? minValue : value;

這應該工作。

變化：

range = maxValue == minValue ? 0 : Math.abs(maxValue - minValue + 1);
value = range == 0 ? maxValue : value + amount <= maxValue && value + amount >= minValue ? value + amount : value + amount > maxValue ? minValue + (((value + amount - maxValue) % range) == 0 ? range : (value + amount - maxValue) % range) - 1 : maxValue - ((Math.abs(amount) - Math.abs(value - minValue + 1)) % range);

Answer 3

好 ！

你不會喜歡這個，但它可以讓你避免添加操作：

（注意代碼在C＃中，因為我這里沒有java）它看起來像這樣：

class MyNumber 
{    
    public int value;
    int minValue, maxValue;
    private int[] range; 
    private int index = 0;

    //Ctor
    public MyNumber(int value, int minValue, int maxValue) 
    {
        if (value < minValue || value > maxValue || maxValue < minValue)            
            throw new Exception("...");

        this.value = value;
        this.minValue = minValue;
        this.maxValue = maxValue;
        range = new int[maxValue - minValue + 1];
        for (int i = 0; i < range.Length; i++)
        {
            range[i] = minValue;
            if (range[i] == value)
                index = i;
            minValue++;
        }
    }

    public void add(int amount)
    {
        if (Math.Abs(amount) > range.Length)
            amount %= range.Length;

        index = Math.Abs(index + amount);
        if (index >= range.Length)
            index %= range.Length;

        value = range[index];
    }
}