具有固定最小值/最大值的加法

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