নেতিবাচক সংখ্যার মোড আমার মস্তিষ্ককে গলে যাচ্ছে

Question

আমি একটি অ্যারের অবস্থান পেতে কোনও পূর্ণসংখ্যাটি মোড করার চেষ্টা করছি যাতে এটি লুপ হয়ে যায়। এরকম 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

আমি এর আগে এটি করেছি তবে কোনও কারণে এটি আমার মস্তিষ্ককে আজ গলে দিচ্ছে :(

Comments

সম্পর্কে আলোচনা দেখুন গাণিতিক উপর মডুলাস math.stackexchange.com/questions/519845/...

— পিপিসি

ব্লগস.এমএসএনএন.মাইক্রোসফট /ericlippert/2011/12/05/ … একটি দুর্দান্ত নিবন্ধ

— সামরা

Answer 1

আমি সর্বদা আমার নিজস্ব 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] এর মধ্যে থাকে। সুতরাং যদি তা একেবারেই নেতিবাচক হয় তবে এর সাথে এম যুক্ত করে এটির মান মোডুলো পরিবর্তন না করে এটি ইতিবাচক পরিসরে রাখবে।

Comments

দ্রষ্টব্য: সম্পূর্ণ সংখ্যা-তাত্ত্বিক সম্পূর্ণতার জন্য, আপনি শীর্ষে একটি লাইন যুক্ত করতে চাইতে পারেন "if (m <0) m = -m;" যদিও এই ক্ষেত্রে এটি বিবেচ্য নয় কারণ "অ্যারেএলংথ" সম্ভবত সর্বদা ইতিবাচক।

— শ্রীভাতসার

আপনি মিটার মান পরীক্ষা করতে যাচ্ছেন, আপনার শূন্যও বাদ দেওয়া উচিত।

— বিলপিজ

@ রুডলেন্ডার্স: না, যদি x = -5 এবং এম = 2 হয় তবে r = x%mতার -1পরে r+mহয় 1। যখন লুপ প্রয়োজন হয় না। মুল বক্তব্যটি হ'ল (উত্তরে আমি যেমন লিখেছি), x%mসর্বদা এর চেয়ে কঠোরতর হয় -m, সুতরাং mএটি ইতিবাচক করতে আপনাকে একবারে যুক্ত করা দরকার ।

— শ্রীভাতসার আর

@dcastro: আমি কি -12 গেলিক ভাষার -10 চান 8. যে এই, গণিত মধ্যে সবচেয়ে সাধারণ সম্মেলন যে প্রতিনিধি অবচয় যদি rজন্য aমডিউল b, তারপর এটা যেমন যে 0 ≤ দ <| খ |।

— শ্রীভাতসার আর

+1 টি। নেতিবাচক মডুলাসের জন্য কোনও স্বতন্ত্র ভাষা কী করে তা আমার খেয়াল নেই - 'সর্বনিম্ন অ-নেতিবাচক অবশিষ্টাংশ' গাণিতিক নিয়মিততা প্রদর্শন করে এবং যে কোনও অস্পষ্টতা দূর করে।

— ব্রেট হ্যালে

Answer 2

দয়া করে নোট করুন যে সি # এবং সি ++ এর% অপারেটরটি আসলে কোনও মডুলো নয়, এটি বাকি। আপনার ক্ষেত্রে মডুলোর যে সূত্র আপনি চান তা হ'ল:

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

আপনাকে এটি সি # (বা সি ++) এ পুনরায় পুনঃনির্মাণ করতে হবে তবে আপনি মোডুলো পেয়ে যাবেন এবং অবশিষ্টটি নয়।

Comments

"দয়া করে নোট করুন যে সি ++ এর% অপারেটরটি আসলে কোনও মডুলো নয়, এটি বাকি।" ধন্যবাদ, এখনই এটি বোধগম্য হয়ে উঠেছে, সর্বদা ভাবছেন কেন এটি নেতিবাচক সংখ্যার সাথে সঠিকভাবে কাজ করে নি।

— leetNightshade

"দয়া করে নোট করুন যে সি ++ এর% অপারেটরটি আসলে কোনও মডুলো নয়, এটি বাকি। এটি এটি মডুলো অপারেশন উইকিপিডিয়া পৃষ্ঠায়ও বলেছে। এটি ঠিক যে প্রোগ্রামিং ভাষা নেতিবাচক সংখ্যার সাথে আলাদা আচরণ করে। সি # তে থাকা মডুলো অপারেটর অবশ্যই "অবশিষ্ট" কে "শূন্য (-9% 4 = -1 থেকে গণনা করে, কারণ 4 * -2--1 এর পার্থক্য সহ) হয় অন্য একটি সংজ্ঞা -9% 4 কে +3 হিসাবে বিবেচনা করবে, কারণ -4 * 3 হ'ল -12, বাকি +3 (যেমন গুগলের অনুসন্ধান ফাংশনে, সেখানে ব্যাক-এন্ড ভাষার বিষয়ে নিশ্চিত নয়)।

— টাইগার

টায়রিস, মডুলাস এবং বাকিগুলির মধ্যে পার্থক্য রয়েছে। উদাহরণস্বরূপ: -21 mod 4 is 3 because -21 + 4 x 6 is 3. তবে -21 divided by 4 gives -5ক remainder of -1। ইতিবাচক মানগুলির জন্য, কোনও পার্থক্য নেই। সুতরাং দয়া করে নিজেকে এই পার্থক্য সম্পর্কে অবহিত করুন। এবং উইকিপিডিয়াকে সবসময় বিশ্বাস করবেন না :)

— Петров Петров

কেউ কেন কোনও মডুলোর পরিবর্তে বাকী কাজটি ব্যবহার করতে চাইবে? কেন তারা %বাকি তৈরি করলেন?

— অ্যারন ফ্রাঙ্ক

@ আরনফ্র্যাঙ্ক - এটি পূর্ববর্তী সিপাসের একটি উত্তরাধিকার যা বিভাগীয় হার্ডওয়্যারটি দিয়ে দ্রুত একটি ভাগফল এবং একটি অবশিষ্ট উত্পাদন তৈরি করতে পারে - এবং এটিই সেই হার্ডওয়্যারটি একটি নেতিবাচক লভ্যাংশ দিয়েছে। ভাষাটি কেবল হার্ডওয়্যারকে মিরর করে তোলে। বেশিরভাগ সময় প্রোগ্রামাররা ইতিবাচক লভ্যাংশ নিয়ে কাজ করছিলেন এবং এই স্পর্শটিকে উপেক্ষা করলেন। গতি ছিল সর্বজনীন।

— টুলমেকারস্টেভ

Answer 3

একক লাইন প্রয়োগ %শুধুমাত্র একবার ব্যবহার করে :

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

Comments

এটা কি সঠিক? যেহেতু আমি এটিকে কারও দ্বারা গ্রহণযোগ্য হিসাবে দেখছি না, বা এটিতে কোনও মন্তব্য নেই। উদাহরণ স্বরূপ. মোড (-10,6) ফিরে আসবে 6 এটি কি সঠিক? এটা 4 ফিরে না?

— জন ডেমেট্রিউ

@ জনডেমিটরিও আপনার সংখ্যা উভয়ই ভুল: (ক) এটি 2 এবং (খ) ফিরে আসবে 2 এটি ফেরত দেয়; কোড চালানোর চেষ্টা করুন। আইটেম (এ): mod(-10, 6)হাতে সন্ধানের জন্য, উত্তর সীমাতে না আসা পর্যন্ত আপনি 6 টি পুনরাবৃত্তি যোগ করুন বা বিয়োগ করুন [0, 6)। এই স্বরলিপিটির অর্থ "বামদিকে অন্তর্ভুক্ত এবং ডানদিকে একচেটিয়া"। আমাদের ক্ষেত্রে, আমরা 2 বার দিয়েছি, 2 বার 2 যোগ করছি, কোডটি বেশ সহজ, এবং এটি ঠিক যে এটি সঠিক তা দেখতে সহজ: প্রথমত, এটি nউপরে হিসাবে যোগ / বিয়োগের সমতুল্য করে , ব্যতীত যদি এটি একটি nসংক্ষিপ্ত থামে , যদি কাছাকাছি পৌঁছায় নেতিবাচক দিক। সেক্ষেত্রে আমরা এটি ঠিক করি। সেখানে: মন্তব্যগুলি :)

— Evgeni Sergeev

যাইহোক, এখানে একক কারণ ব্যবহার করা %ভাল ধারণা হতে পারে। দ্রুত পরিচালিত কোড রচনা নিবন্ধটিতে পরিচালিত কোডে কী কী জিনিসগুলি সারণীটি দেখুন : কী কী জিনিস ব্যয় করে তা জানুন । টেবিলের তালিকাভুক্ত %করা একইভাবে ব্যবহার করা ব্যয়বহুল int div: যোগ বা বিয়োগের চেয়ে প্রায় 36 গুণ বেশি ব্যয়বহুল এবং গুণনের চেয়ে 13 গুণ বেশি ব্যয়বহুল। অবশ্যই, আপনার কোড কী করছে তার মূলে এটি না থাকলে কোনও বড় কথা।

— এভেজেনি সার্জিভ

তবে কি %পরীক্ষা এবং লাফানোর চেয়ে আরও বেশি ব্যয়বহুল, বিশেষত যদি এটি সহজেই অনুমান করা যায় না?

— মেডিনোক

Answer 4

আপনি যদি নেতিবাচক লভ্যাংশ / বিভাজক হিসাবে বিবেচনা করেন তবে "যদি (এম <0) মি = -m;" যোগ করেন তবেও শ্রীভাতসার এর উত্তর সমস্ত ক্ষেত্রে কার্যকর হবে না।

উদাহরণস্বরূপ, -12 মোড -10 হবে 8, এবং এটি -2 হওয়া উচিত।

নিম্নলিখিত প্রয়োগটি ইতিবাচক এবং নেতিবাচক লভ্যাংশ / বিভাজন উভয়ের জন্য কাজ করবে এবং অন্যান্য বাস্তবায়ন (যথা, জাভা, পাইথন, রুবি, স্কালা, স্কিম, জাভাস্ক্রিপ্ট এবং গুগলের ক্যালকুলেটর) এর সাথে সম্মতি জানায়:

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

Comments

প্রথমত, একটি modক্রিয়াকলাপটি সাধারণত পজিটিভ মডুলাসের সাথে ডাকা হয় ( arrayLengthএখানে মূল প্রশ্নের যে ভেরিয়েবলটি উত্তর দেওয়া হচ্ছে তা নোট করুন, সম্ভবত এটি কখনও নেতিবাচক নয়), সুতরাং কার্যকারিতাটি আসলে নেতিবাচক মডুলাসের জন্য কাজ করার প্রয়োজন হবে না। (এ কারণেই আমি আমার উত্তরের একটি মন্তব্যে নেতিবাচক মডুলাসের চিকিত্সা উল্লেখ করেছি, উত্তরে নয়)) (চালিত ...)

— শ্রীভাতসার

(... নিয়ন্ত্রিত) দ্বিতীয়ত, নেতিবাচক মডুলাসের জন্য কী করা উচিত তা কনভেনশনের বিষয়। যেমন উইকিপিডিয়া দেখুন । "সাধারণত, সংখ্যার তত্ত্বের ক্ষেত্রে ইতিবাচক বাকীটি সর্বদা বেছে নেওয়া হয়", এবং এটি আমি এটিও শিখেছি (বার্টনের প্রাথমিক সংখ্যা তত্ত্বে )। নুথও সেভাবে এটি সংজ্ঞায়িত করে (বিশেষত, r = a - b floor(a/b)সর্বদা ইতিবাচক)। এমনকি কম্পিউটার সিস্টেমগুলির মধ্যে, উদাহরণস্বরূপ পাস্কাল এবং ম্যাপেল, এটি সর্বদা ইতিবাচক হিসাবে সংজ্ঞায়িত করে।

— শ্রীভাতসার আর

@ শ্রীভাতসারআর আমি জানি যে ইউক্যালিডিয়ান সংজ্ঞা বলছে যে ফলাফলটি সর্বদা ইতিবাচক হবে - তবে আমি এই ধারণার অধীনে রয়েছি যে বেশিরভাগ আধুনিক আধুনিকায়নগুলি একটি নেতিবাচক বিভাজন "এন" এর জন্য [n + 1, 0] পরিসীমাতে একটি মান ফিরিয়ে দেবে, যার অর্থ -12 মোড -10 = -2। Ive গুগল ক্যালকুলেটর , পাইথন , রুবি এবং স্কালায় সন্ধান করেছে এবং তারা সকলেই এই সম্মেলনটি অনুসরণ করে।

— ডাস্ট্রো

এছাড়াও, তালিকায় যুক্ত করতে: স্কিম এবং জাভাস্ক্রিপ্ট

— ডেস্কট্রো

আবার, এই এখনও একটি ভাল পঠিত। "সর্বদা ইতিবাচক" সংজ্ঞা (আমার উত্তর) ALGOL, ডার্ট, ম্যাপেল, পাস্কেল, জেড 3, ইত্যাদির সাথে সামঞ্জস্যপূর্ণ etc. এক্সেল, পার্ল, পাইথন, আর, রুবি, টিসিএল, ইত্যাদি উভয়ই "লভ্যাংশের চিহ্ন" এর সাথে বেমানান: এডাব্লুকে, বাশ, বিসি, সি 99, সি ++ 11, সি #, ডি, আইফেল, এরলং, গো, জাভা , ওক্যামল, পিএইচপি, মরিচা, স্কেলা, সুইফ্ট, ভিবি, এক্স 86 অ্যাসেম্বলি ইত্যাদি etc. আমি সত্যিই দেখছি না যে আপনি কীভাবে একটি কনভেনশন দাবি করতে পারেন "সঠিক" এবং অন্যরা "ভুল"।

— শ্রীভাতসারআর

Answer 5

কিছুটা বোঝাপড়া যুক্ত করা হচ্ছে।

দ্বারা ইউক্লিডিয় সংজ্ঞা গেলিক ভাষার ফলাফলের সবসময় ইতিবাচক হতে হবে।

উদা:

 int n = 5;
 int x = -3;

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

আউটপুট:

 -1

Comments

আমি বিভ্রান্ত হয়ে পড়েছি ... আপনি বলছেন যে ফলাফলটি সর্বদা ইতিবাচক হওয়া উচিত তবে তারপরে আউটপুটটি তালিকাভুক্ত করবেন -1?

— জেফ বি

@ জেফব্রিডগম্যান আমি ইউক্লিডিয়ান সংজ্ঞার ভিত্তিতে এটি বলেছি। the বাকিগুলির জন্য দুটি সম্ভাব্য পছন্দ রয়েছে, একটি নেতিবাচক এবং অন্যটি ইতিবাচক এবং ভাগফলের জন্য দুটি সম্ভাব্য পছন্দও রয়েছে। সাধারণত, সংখ্যার তত্ত্বে, the positive remainder is always chosenতবে প্রোগ্রামিং ভাষাগুলি ভাষা এবং একটি এবং / বা এন এর চিহ্নগুলির উপর নির্ভর করে চয়ন করে [[5] স্ট্যান্ডার্ড Pascal এবং Algol68 এমনকি নেতিবাচক ভাজক জন্য একটি ইতিবাচক বাকি (অথবা 0) দিতে, এবং এই ধরনের C90 কিছু প্রোগ্রামিং ভাষা, এটা n এর বাস্তবায়নে ছেড়ে যখন করুন অথবা একটি negative.` হয়

— Abin

Answer 6

দুটি প্রধান উত্তর তুলনা করা

(x%m + m)%m;

এবং

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

কেউই আসলে এই সত্যটির উল্লেখ করেনি যে প্রথমটি OverflowExceptionকিছুক্ষণ ফেলে দিতে পারে যখন দ্বিতীয়টি তা না করে। আরও খারাপ, ডিফল্ট চেক না করা প্রসঙ্গে, প্রথম উত্তরটি ভুল উত্তর দিতে পারে ( mod(int.MaxValue - 1, int.MaxValue)উদাহরণস্বরূপ দেখুন)। সুতরাং দ্বিতীয় উত্তরটি কেবল দ্রুত বলে মনে হচ্ছে না, তবে আরও সঠিক।

Answer 7

% এর নেতিবাচক ফলাফলের জন্য কেবল আপনার মডুলাস (অ্যারেলিঙ্গ) যুক্ত করুন এবং আপনি ভাল থাকবেন।

Answer 8

আরও কর্মক্ষমতা সচেতন ডেভস জন্য

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 কাস্ট কর্মক্ষমতা খরচ জন্য একটি চেহারা আছে এখানে

Comments

-3 % 10হয় -৩ বা be. হওয়া উচিত এমন পদ্ধতিগুলি যেহেতু একটি অ-নেতিবাচক ফলাফল চাওয়া, তাই 7 উত্তর হবে। আপনার বাস্তবায়ন ফিরে আসে 3. আপনার উভয় পরামিতি পরিবর্তন করা উচিত uintএবং কাস্ট মুছে ফেলা উচিত ।

— আমি পুরানো স্ট্যাক ওভারফ্লো

স্বাক্ষরযুক্ত গাণিতিকটি কেবলমাত্র nদুটি এর শক্তির সমতুল্য , এর ক্ষেত্রে আপনি কেবলমাত্র একটি লজিকাল এবং ( (uint)k & (n - 1)) পরিবর্তে ব্যবহার করতে পারেন , যদি সংকলক ইতিমধ্যে এটি আপনার জন্য না করে (সংকলকরা প্রায়শই এটি নির্ধারণ করার জন্য যথেষ্ট স্মার্ট থাকে)।

— j_schultz

Answer 9

আমি এই থ্রেডে পিটার এন লুইসের উপস্থাপিত কৌশলটি পছন্দ করি : "যদি এন এর একটি সীমিত পরিসর থাকে তবে আপনি [বিভাজক] এর পরিচিত ধ্রুবক একাধিক যোগ করে আপনি যে ফলাফলটি চান তা পেতে পারেন যা এর পরম মান এর চেয়ে বেশি সর্বনিম্ন। "

সুতরাং যদি আমি একটি মান আছে ঘ ডিগ্রীতে যে আমি নিতে চান

d % 180f

এবং আমি সমস্যাগুলি এড়াতে চাই যদি ডি নেতিবাচক হয় তবে তার পরিবর্তে আমি কেবল এটি করি:

(d + 720f) % 180f

এই অনুমান যদিও যে ঘ নেতিবাচক হতে পারে, এটা জানা যায় এটা -720 চেয়ে বেশি নেতিবাচক হতে হবে।

Comments

-1: পর্যাপ্ত সাধারণ নয়, (এবং আরও সাধারণ সমাধান দেওয়া খুব সহজ)।

— এভেজেনি সার্জিভ

এটি আসলে খুব সহায়ক। যখন আপনার অর্থপূর্ণ পরিসীমা থাকে, এটি গণনা সহজতর করতে পারে। আমার ক্ষেত্রে math.stackexchange.com/questions/2279751/…

— এম.কাজেম আখগারি

হুবহু, এটি স্রেফ ডে-অফ উইক গণনার জন্য ব্যবহার করা হয়েছে (-6 থেকে +6 এর পরিসীমা পরিচিত) এবং এটি দুটি করে সংরক্ষণ করেছে %।

— নেটমেজ

আমার জন্য @ এজেন্সি সার্জিভ +0: ওপি প্রশ্নের উত্তর দেয় না তবে আরও নির্দিষ্ট প্রসঙ্গে (তবে এখনও প্রশ্নের প্রসঙ্গে) সহায়ক হতে পারে

— এরদল জি।

Answer 10

আপনি এমন আচরণের প্রত্যাশা করছেন যা সি # তে% অপারেটরের ডকুমেন্টেড আচরণের বিপরীত - সম্ভবত আপনি এটি এমনভাবে কাজ করার প্রত্যাশা করছেন যা আপনি অন্য ভাষায় ব্যবহার করেন যা আপনি বেশি অভ্যস্ত। ডকুমেন্টেশন C # রাজ্যের (জোর খনি) করুন:

পূর্ণসংখ্যার ধরণের অপারেন্ডগুলির জন্য,% b এর ফলাফল হ'ল একটি - (a / b) * খ দ্বারা উত্পাদিত মান। শূন্য-র অবশিষ্ট অংশের চিহ্নটি বাম-হাতের ক্রিয়াকলাপের সমান

আপনি যে মানটি চান সেটি একটি অতিরিক্ত পদক্ষেপের সাথে গণনা করা যেতে পারে:

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

Answer 11

আপনার বিভাজকটি ইতিবাচক হলে এখানে সমস্ত উত্তর দুর্দান্ত কাজ করে তবে এটি সম্পূর্ণ সম্পূর্ণ নয়। এখানে আমার বাস্তবায়ন যা সর্বদা একটি ব্যাপ্তিতে ফিরে আসে [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কোনও সংখ্যার প্রকার থাকতে পারে)

Answer 12

ড্যাসট্রোর জবাবের একক লাইন বাস্তবায়ন (অন্যান্য ভাষার সাথে সর্বাধিক অনুগত):

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

আপনি যদি %অপারেটরের ব্যবহার রাখতে চান (আপনি সি # তে নেটিভ অপারেটরগুলি ওভারলোড করতে পারবেন না):

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