Question

主要编辑：100％解决了！它被称为模块化算术，感谢Peter !!

我需要添加两个具有固定最小/最大值的数字。我希望我的数字表现得像java＆int; 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 - ＆gt; 4 - ＆gt; 5 - ＆gt; 2 - ＆gt; 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

我会尽量让事情变得清晰。 e.g

如果你想要时钟算术，你可以做

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

添加固定的最小/最大值

3 个答案: