음수의 모드는 내 뇌를 녹이고있다

배열 위치를 얻기 위해 정수를 수정하여 루프가 순환되도록합니다. 이렇게 i % arrayLength양수를 위해 작품의 벌금을하지만 음수 모든 잘못 간다.

 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

그래서 나는 구현이 필요하다

int GetArrayIndex(int i, int arrayLength)

그런

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

나는 전에 이것을했지만 어떤 이유로 든 오늘 내 두뇌가 녹고있다 :(

나는 항상 내 자신의 mod기능을 사용합니다.

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

물론, 모듈러스 연산 에 대한 두 번의 호출이 걱정된다면 , 다음과 같이 쓸 수 있습니다.

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

또는 이의 변형.

작동하는 이유는 "x % m"이 항상 [-m + 1, m-1] 범위에 있기 때문입니다. 따라서 음수이면 m을 추가하면 값 modulo m을 변경하지 않고 양수 범위에 놓입니다.

C #과 C ++의 % 연산자는 실제로 모듈로가 아니며 나머지입니다. 원하는 경우 모듈로의 공식은 다음과 같습니다.

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

이것을 C # (또는 C ++)으로 다시 코딩해야하지만 나머지가 아닌 모듈로를 얻는 방법입니다.

%한 번만 사용하는 단일 라인 구현 :

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

부정적인 배당 / 제수를 설명하는 경우 "if (m <0) m = -m;"을 추가하더라도 ShreevatsaR의 답변은 모든 경우에 적용되지 않습니다.

예를 들어, -12 mod -10은 8이고 -2 여야합니다.

다음 구현은 양수 및 음수 배당 / 제수 모두에 대해 작동하며 다른 구현 (즉, Java, Python, Ruby, Scala, Scheme, Javascript 및 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;
    }
}

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

이해력 향상.

으로 유클리드의 정의 유행의 결과는 항상 양수 여야합니다.

전의:

 int n = 5;
 int x = -3;

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

산출:

 -1

두 가지 주요 답변 비교

(x%m + m)%m;

과

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

실제로 첫 번째 것은 OverflowException잠시 동안 던질 수 있고 두 번째는 그렇지 않을 것이라는 사실을 언급 한 사람은 없습니다. 더 나쁜 것은 기본 확인되지 않은 컨텍스트를 사용하면 첫 번째 답변이 잘못된 답변을 반환 할 수 있습니다 ( mod(int.MaxValue - 1, int.MaxValue)예 : 참조 ). 따라서 두 번째 대답은 더 빠를뿐만 아니라 더 정확한 것처럼 보입니다.

모듈러스 (arrayLength)를 %의 음수 결과에 추가하기 만하면됩니다.

더 성능을 인식하는 개발자를 위해

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

작은 성능 비교

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

uint 로의 캐스트 성능 비용은 여기를 참조하십시오.

이 스레드 에서 Peter N Lewis가 제시 한 트릭이 마음에 듭니다. . "n에 범위가 제한되어 있으면 [제수]의 알려진 상수 배수를 절대 값보다 크게 추가하여 원하는 결과를 얻을 수 있습니다. 최저한의."

그래서 내가 d 값을 가지고 있고 가지고 싶습니다.

d % 180f

d 가 음수 이면 문제를 피하고 싶습니다. 대신이 작업을 수행합니다.

(d + 720f) % 180f

d 는 음수 일 수 있지만 -720보다 음수가 아닌 것으로 알려져 있습니다.

c #에서 % 연산자의 문서화 된 동작과 반대되는 동작을 기대하고 있습니다. 아마도 더 익숙한 다른 언어로 작동하는 방식으로 작동하기를 기대하기 때문일 수 있습니다. C # 상태에 대한 설명서 (강조 광산) :

정수 유형의 피연산자의 경우 a % b의 결과는 a-(a / b) * b에 의해 생성 된 값입니다. 0이 아닌 나머지의 부호는 왼쪽 피연산자의 부호와 같습니다.

하나의 추가 단계로 원하는 값을 계산할 수 있습니다.

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

dcastro 의 답변 한 줄로 구현 (다른 언어와 가장 호환) :

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

%연산자 를 계속 사용하려면 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);
}

유스 케이스, 둘 다 작동합니다.

int r = (IntM)a % n;

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

여기에있는 모든 답변은 제수가 긍정적 인 경우 효과적이지만 완벽하지는 않습니다. 다음은 항상 범위에서 반환되는 구현입니다.[0, b)출력의 부호가 제수의 부호와 같도록 음의 제수를 출력 범위의 끝점으로 사용할 수 있도록 있습니다.

PosMod(5, 3)리턴 2
PosMod(-5, 3)리턴 1
PosMod(5, -3)리턴 -1
PosMod(-5, -3)리턴-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;
    }

(여기서 real_t숫자 유형이 될 수 있음)