จำนวนโมดิฟลบกำลังละลายสมองของฉัน

ฉันพยายามที่จะแก้ไขจำนวนเต็มเพื่อให้ได้ตำแหน่งอาเรย์เพื่อที่จะวนรอบ การ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 ลงไปจะอยู่ในช่วงบวกโดยไม่เปลี่ยนค่าโมดูโล m

โปรดทราบว่าโอเปอเรเตอร์% C ของ C และ C ++ นั้นไม่ใช่โมดูโล สูตรสำหรับ modulo ที่คุณต้องการในกรณีของคุณคือ:

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

คุณต้องบันทึกสิ่งนี้ใหม่ใน C # (หรือ C ++) แต่นี่เป็นวิธีที่คุณได้รับ modulo ไม่ใช่ส่วนที่เหลือ

การใช้งานแบบบรรทัด%เดียวโดยใช้เพียงครั้งเดียว:

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

คำตอบของ ShreevatsaR จะไม่ทำงานในทุกกรณีแม้ว่าคุณจะเพิ่ม "ถ้า (m <0) m = -m;" หากคุณบัญชีสำหรับเงินปันผล / ตัวลบ

ตัวอย่างเช่น -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 };
        }
    }

การเพิ่มความเข้าใจ

โดยนิยามแบบยุคลิดผลลัพธ์ mod จะต้องเป็นบวกเสมอ

Ex:

 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) ไปยังผลลัพธ์เชิงลบของ% และคุณจะไม่เป็นไร

สำหรับ devs การรับรู้ประสิทธิภาพมากขึ้น

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 เครื่องหมายของส่วนที่เหลือที่ไม่ใช่ศูนย์จะเหมือนกับสัญญาณของตัวถูกดำเนินการทางซ้าย

ค่าที่คุณต้องการสามารถคำนวณได้ด้วยขั้นตอนพิเศษหนึ่งขั้น:

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สามารถเป็นประเภทใดก็ได้)