Mod của số âm đang làm tan chảy não của tôi

Tôi đang cố gắng sửa đổi một số nguyên để có được một vị trí mảng để nó sẽ lặp vòng. Làm i % arrayLengthtốt cho số dương nhưng với số âm thì tất cả đều sai.

 4 % 3 == 1
 3 % 3 == 0
 2 % 3 == 2
 1 % 3 == 1
 0 % 3 == 0
-1 % 3 == -1
-2 % 3 == -2
-3 % 3 == 0
-4 % 3 == -1

vì vậy tôi cần thực hiện

int GetArrayIndex(int i, int arrayLength)

như vậy mà

GetArrayIndex( 4, 3) == 1
GetArrayIndex( 3, 3) == 0
GetArrayIndex( 2, 3) == 2
GetArrayIndex( 1, 3) == 1
GetArrayIndex( 0, 3) == 0
GetArrayIndex(-1, 3) == 2
GetArrayIndex(-2, 3) == 1
GetArrayIndex(-3, 3) == 0
GetArrayIndex(-4, 3) == 2

Tôi đã làm điều này trước đây nhưng vì một số lý do, nó làm tan chảy bộ não của tôi ngày hôm nay :(

Tôi luôn sử dụng modchức năng của riêng mình , được định nghĩa là

int mod(int x, int m) {
    return (x%m + m)%m;
}

Tất nhiên, nếu bạn bận tâm về việc có hai cuộc gọi đến hoạt động mô đun, bạn có thể viết nó dưới dạng

int mod(int x, int m) {
    int r = x%m;
    return r<0 ? r+m : r;
}

hoặc các biến thể của chúng.

Lý do nó hoạt động là "x% m" luôn nằm trong phạm vi [-m + 1, m-1]. Vì vậy, nếu ở tất cả nó là âm, thêm m vào nó sẽ đặt nó trong phạm vi dương mà không thay đổi giá trị modulo m của nó.

Xin lưu ý rằng toán tử% của C # và C ++ thực sự KHÔNG phải là modulo, phần còn lại. Công thức cho modulo mà bạn muốn, trong trường hợp của bạn, là:

float nfmod(float a,float b)
{
    return a - b * floor(a / b);
}

Bạn phải mã hóa lại điều này trong C # (hoặc C ++) nhưng đây là cách bạn có được modulo chứ không phải phần còn lại.

Thực hiện một dòng %chỉ sử dụng một lần:

int mod(int k, int n) {  return ((k %= n) < 0) ? k+n : k;  }

Câu trả lời của ShreevatsaR sẽ không hoạt động trong mọi trường hợp, ngay cả khi bạn thêm "if (m <0) m = -m;", nếu bạn tính đến cổ tức / ước số âm.

Ví dụ: -12 mod -10 sẽ là 8 và nó phải là -2.

Việc triển khai sau đây sẽ hoạt động cho cả cổ tức / ước tính tích cực và tiêu cực và tuân thủ các triển khai khác (cụ thể là Java, Python, Ruby, Scala, Scheme, Javascript và Máy tính của Google):

internal static class IntExtensions
{
    internal static int Mod(this int a, int n)
    {
        if (n == 0)
            throw new ArgumentOutOfRangeException("n", "(a mod 0) is undefined.");

        //puts a in the [-n+1, n-1] range using the remainder operator
        int remainder = a%n;

        //if the remainder is less than zero, add n to put it in the [0, n-1] range if n is positive
        //if the remainder is greater than zero, add n to put it in the [n-1, 0] range if n is negative
        if ((n > 0 && remainder < 0) ||
            (n < 0 && remainder > 0))
            return remainder + n;
        return remainder;
    }
}

Bộ kiểm tra sử dụng xUnit:

    [Theory]
    [PropertyData("GetTestData")]
    public void Mod_ReturnsCorrectModulo(int dividend, int divisor, int expectedMod)
    {
        Assert.Equal(expectedMod, dividend.Mod(divisor));
    }

    [Fact]
    public void Mod_ThrowsException_IfDivisorIsZero()
    {
        Assert.Throws<ArgumentOutOfRangeException>(() => 1.Mod(0));
    }

    public static IEnumerable<object[]> GetTestData
    {
        get
        {
            yield return new object[] {1, 1, 0};
            yield return new object[] {0, 1, 0};
            yield return new object[] {2, 10, 2};
            yield return new object[] {12, 10, 2};
            yield return new object[] {22, 10, 2};
            yield return new object[] {-2, 10, 8};
            yield return new object[] {-12, 10, 8};
            yield return new object[] {-22, 10, 8};
            yield return new object[] { 2, -10, -8 };
            yield return new object[] { 12, -10, -8 };
            yield return new object[] { 22, -10, -8 };
            yield return new object[] { -2, -10, -2 };
            yield return new object[] { -12, -10, -2 };
            yield return new object[] { -22, -10, -2 };
        }
    }

Thêm một số hiểu biết.

Theo định nghĩa Euclide , kết quả mod phải luôn dương.

Ví dụ:

 int n = 5;
 int x = -3;

 int mod(int n, int x)
 {
     return ((n%x)+x)%x;
 }

Đầu ra:

 -1

So sánh hai câu trả lời chiếm ưu thế

(x%m + m)%m;

và

int r = x%m;
return r<0 ? r+m : r;

Không ai thực sự đề cập đến thực tế rằng người đầu tiên có thể ném một OverflowExceptionlúc người thứ hai sẽ không. Thậm chí tệ hơn, với bối cảnh không được kiểm tra mặc định, câu trả lời đầu tiên có thể trả về câu trả lời sai (xem mod(int.MaxValue - 1, int.MaxValue)ví dụ). Vì vậy, câu trả lời thứ hai không chỉ có vẻ nhanh hơn, mà còn đúng hơn.

Chỉ cần thêm mô-đun của bạn (mảng Độ dài) vào kết quả âm của% và bạn sẽ ổn.

Đối với các nhà phát triển nhận thức hiệu suất cao hơn

uint wrap(int k, int n) ((uint)k)%n

Một so sánh hiệu suất nhỏ

Modulo: 00:00:07.2661827 ((n%x)+x)%x)
Cast:   00:00:03.2202334 ((uint)k)%n
If:     00:00:13.5378989 ((k %= n) < 0) ? k+n : k

Đối với chi phí hiệu suất của dàn diễn viên để uint có một cái nhìn ở đây

Tôi thích thủ thuật được trình bày bởi Peter N Lewis chủ đề này : "Nếu n có phạm vi giới hạn, thì bạn có thể nhận được kết quả bạn muốn chỉ bằng cách thêm bội số đã biết của [ước số] lớn hơn giá trị tuyệt đối của tối thiểu. "

Vì vậy, nếu tôi có một giá trị d tính bằng độ và tôi muốn lấy

d % 180f

và tôi muốn tránh các vấn đề nếu d âm tính, thay vào đó tôi chỉ làm điều này:

(d + 720f) % 180f

Điều này giả định rằng mặc dù d có thể âm, nhưng người ta biết rằng nó sẽ không bao giờ âm hơn -720.

Bạn đang mong đợi một hành vi trái với hành vi được ghi lại của toán tử% trong c # - có thể vì bạn đang mong đợi nó hoạt động theo cách mà nó hoạt động theo ngôn ngữ khác mà bạn quen dùng hơn. Các tài liệu về c # bang (tôi nhấn mạnh):

Đối với các toán hạng của các kiểu số nguyên, kết quả của% b là giá trị được tạo bởi a - (a / b) * b. Dấu của phần còn lại khác không giống với dấu của toán hạng bên trái

Giá trị bạn muốn có thể được tính bằng một bước bổ sung:

int GetArrayIndex(int i, int arrayLength){
    int mod = i % arrayLength;
    return (mod>=0) : mod ? mod + arrayLength;
}

Tất cả các câu trả lời ở đây hoạt động rất tốt nếu ước số của bạn là tích cực, nhưng nó không hoàn toàn đầy đủ. Đây là cách thực hiện của tôi, nó luôn trả về một phạm vi[0, b) , sao cho dấu của đầu ra giống như dấu của ước số, cho phép các ước số âm làm điểm cuối cho phạm vi đầu ra.

PosMod(5, 3)trả 2
PosMod(-5, 3)về 1
PosMod(5, -3)trả -1
PosMod(-5, -3)về trả về-2

    /// <summary>
    /// Performs a canonical Modulus operation, where the output is on the range [0, b).
    /// </summary>
    public static real_t PosMod(real_t a, real_t b)
    {
        real_t c = a % b;
        if ((c < 0 && b > 0) || (c > 0 && b < 0)) 
        {
            c += b;
        }
        return c;
    }

(nơi real_tcó thể là bất kỳ loại số nào)

Một dòng thực hiện câu trả lời của dcastro (phù hợp nhất với các ngôn ngữ khác):

int Mod(int a, int n)
{
    return (((a %= n) < 0) && n > 0) || (a > 0 && n < 0) ? a + n : a;
}

Nếu bạn muốn tiếp tục sử dụng %toán tử (bạn không thể quá tải toán tử gốc trong C #):

public class IntM
{
    private int _value;

    private IntM(int value)
    {
        _value = value;
    }

    private static int Mod(int a, int n)
    {
        return (((a %= n) < 0) && n > 0) || (a > 0 && n < 0) ? a + n : a;
    }

    public static implicit operator int(IntM i) => i._value;
    public static implicit operator IntM(int i) => new IntM(i);
    public static int operator %(IntM a, int n) => Mod(a, n);
    public static int operator %(int a, IntM n) => Mod(a, n);
}

Ca sử dụng, cả hai tác phẩm:

int r = (IntM)a % n;

// Or
int r = a % n(IntM);