প্রদত্ত ব্যাপ্তিতে সমস্ত সংখ্যার XOR সন্ধান করুন

Question 1

আপনাকে একটি বিশাল পরিসর দেওয়া হয়েছে [a, b] যেখানে 'a' এবং 'b' সাধারণত 1 এবং 4,000,000,000 এর মধ্যে থাকতে পারে। আপনাকে প্রদত্ত ব্যাপ্তির সমস্ত সংখ্যার XOR বের করতে হবে।

এই সমস্যাটি টপকোডার এসআরএম-এ ব্যবহৃত হয়েছিল। আমি ম্যাচে জমা দেওয়া সমাধানগুলির মধ্যে একটি দেখেছি এবং এটি কীভাবে কাজ করছে তা অনুধাবন করতে পারছি না।

বিজয়ী সমাধানটি ব্যাখ্যা করতে কেউ সহায়তা করতে পারে:

long long f(long long a) {
     long long res[] = {a,1,a+1,0};
     return res[a%4];
}

long long getXor(long long a, long long b) {
     return f(b)^f(a-1);
}

এখানে, getXor()উত্তীর্ণ পরিসীমা [a, b] এবং "f ()" এর সমস্ত সংখ্যার জোরকে গণনা করার আসল ফাংশনটি হেল্পার ফাংশন।

Question 2

এটি একটি চমত্কার চালাক সমাধান - এটি চলমান XORs এ ফলাফলের একটি প্যাটার্ন রয়েছে যে সত্যটি কাজে লাগায়। f()ফাংশন থেকে XOR যাও মোট রান [0, একটি] হিসাব করে। 4-বিট সংখ্যার জন্য এই টেবিলটি একবার দেখুন:

0000 <- 0  [a]
0001 <- 1  [1]
0010 <- 3  [a+1]
0011 <- 0  [0]
0100 <- 4  [a]
0101 <- 1  [1]
0110 <- 7  [a+1]
0111 <- 0  [0]
1000 <- 8  [a]
1001 <- 1  [1]
1010 <- 11 [a+1]
1011 <- 0  [0]
1100 <- 12 [a]
1101 <- 1  [1]
1110 <- 15 [a+1]
1111 <- 0  [0]

যেখানে প্রথম কলামটি বাইনারি উপস্থাপনা এবং তারপরে দশমিক ফলাফল এবং এর সূচক (ক) এর সাথে এটি XOR তালিকার সাথে সম্পর্কিত। এটি ঘটে কারণ সমস্ত উপরের বিটগুলি বাতিল হয়ে যায় এবং প্রতি 4 সর্বনিম্ন দুটি বিট চক্র হয়,

এখন [a, b] এর একটি সাধারণ পরিসীমা বিবেচনা করুন। আমরা f()[0, a-1] এবং [0, খ] এর জন্য এক্সওআর খুঁজে পেতে ব্যবহার করতে পারি । যেহেতু নিজের সাথে এক্সওআর'র কোনও মান শূন্য, তাই এক্সওআর-এর f(a-1)সমস্ত মান কম বাদ দেয় aকেবলমাত্র আপনাকে রেঞ্জের [এ, বি] এর এক্সওর রেখে দেয় ।

Question 3

ফ্যাটালআরারের দুর্দান্ত উত্তরে যুক্ত করে লাইনটি return f(b)^f(a-1);আরও ভালভাবে ব্যাখ্যা করা যেতে পারে। সংক্ষেপে, এর কারণ XOR এর এই দুর্দান্ত বৈশিষ্ট্যগুলি রয়েছে:

এটা মিশুক - প্লেস বন্ধনী আপনি যেখানেই থাকুন না কেন আপনি চান
এটা পরিবহণযোগ্য - অর্থ আপনি অপারেটরদের চারদিকে সরিয়ে নিতে পারেন (তারা "যাত্রা" করতে পারেন)

এখানে উভয়ই কর্মক্ষম:

(a ^ b ^ c) ^ (d ^ e ^ f) = (f ^ e) ^ (d ^ a ^ b) ^ c

এটা নিজেই বিপরীত হয়

এটার মত:

a ^ b = c
c ^ a = b

অন্যান্য সাহসী / পরিবহিত অপারেটরগুলির দুটি উদাহরণ হ'ল যোগ এবং গুণ করা, তবে তারা নিজেরাই বিপরীত হয় না। ঠিক আছে, তাই, কেন এই বৈশিষ্ট্যগুলি গুরুত্বপূর্ণ? ঠিক আছে, একটি সরল রুট হ'ল এটিকে প্রকৃতপক্ষে কীভাবে প্রসারিত করা যায় এবং তারপরে আপনি এই বৈশিষ্ট্যগুলি কর্মক্ষেত্রে দেখতে পাবেন।

প্রথমে আসুন আমরা যা চাই তা সংজ্ঞায়িত করি এবং এটিকে n বলি:

n      = (a ^ a+1 ^ a+2 .. ^ b)

এটি যদি সহায়তা করে তবে এক্সওআর (^) এর মতো মনে করুন যেন এটি অ্যাড was

আসুন ফাংশনটি সংজ্ঞায়িত করুন:

f(b)   = 0 ^ 1 ^ 2 ^ 3 ^ 4 .. ^ b

bএর চেয়েও বড় a, তাই কেবলমাত্র কয়েকটি অতিরিক্ত বন্ধনীতে নিরাপদে ফেলে (যা আমরা এটির সহযোগী কারণ) আমরা এটিও বলতে পারি:

f(b)   = ( 0 ^ 1 ^ 2 ^ 3 ^ 4 .. ^ (a-1) ) ^ (a ^ a+1 ^ a+2 .. ^ b)

যা এটিকে সরল করে:

f(b)   = f(a-1) ^ (a ^ a+1 ^ a+2 .. ^ b)

f(b)   = f(a-1) ^ n

এর পরে, আমরা আমাদের যাদু লাইনের জন্য সেই বিপরীত সম্পত্তি এবং চালচলন ব্যবহার করি:

n      = f(b) ^ f(a-1)

আপনি যদি কোনও অ্যাডের মতো এক্সওআর নিয়ে ভাবছিলেন, আপনি সেখানে একটি বিয়োগফল ফেলেছেন। এক্সওআর হ'ল এক্সওআরকে যোগকে বিয়োগ করতে হবে!

আমি কীভাবে এই বিষয়টি নিয়ে আসব?

লজিকাল অপারেটরগুলির বৈশিষ্ট্যগুলি মনে রাখবেন। তাদের সাথে প্রায় একটি অ্যাডের মতো কাজ করুন বা যদি এটি সাহায্য করে তবে গুণ করুন। এটি অস্বাভাবিক বোধ করে যে এবং (&), xor (^) এবং বা (|) সম্মিলিত, তবে তারা!

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

Question 4

আমি জানতে পেরেছি যে নীচের কোডটিও প্রশ্নের উত্তর দেওয়া সমাধানের মতো কাজ করছে।

এটি হতে পারে কিছুটা অপ্টিমাইজড তবে এটি পুনরাবৃত্তি পর্যবেক্ষণ থেকে যেমনটি পেয়েছি ঠিক তেমন গ্রহণযোগ্য উত্তরে দেওয়া হয়েছে,

আমি প্রদত্ত কোডের পিছনে গাণিতিক প্রমাণগুলি জানতে / বুঝতে চাই, যেমন @ লুক ব্রিগেস দ্বারা উত্তরে ব্যাখ্যা করা হয়েছে

এই যে জাভা কোড

public int findXORofRange(int m, int n) {
    int[] patternTracker;

    if(m % 2 == 0)
        patternTracker = new int[] {n, 1, n^1, 0};
    else
        patternTracker = new int[] {m, m^n, m-1, (m-1)^n};

    return patternTracker[(n-m) % 4];
}

Question 5

আমি পুনরাবৃত্তি দিয়ে সমস্যার সমাধান করেছি। আমি কেবল প্রতিটি পুনরাবৃত্তির জন্য ডেটাসেটকে প্রায় সমান অংশে বিভক্ত করি।

public int recursion(int M, int N) {
    if (N - M == 1) {
        return M ^ N;
    } else {
        int pivot = this.calculatePivot(M, N);
        if (pivot + 1 == N) {
            return this.recursion(M, pivot) ^ N;
        } else {
            return this.recursion(M, pivot) ^ this.recursion(pivot + 1, N);
        }
    }
}
public int calculatePivot(int M, int N) {
    return (M + N) / 2;
}

সমাধান সম্পর্কে আপনার চিন্তা আমাকে জানাতে দিন। উন্নতি ফিডব্যাকস পেয়ে খুশি। প্রস্তাবিত সমাধানটি 0 (লগ এন) জটিলতায় XOR গণনা করে।

ধন্যবাদ

Question 6

XOR কে 0 থেকে N পর্যন্ত সমর্থন করার জন্য প্রদত্ত কোডটি নীচের মত সংশোধন করতে হবে,

int f(int a) {
    int []res = {a, 1, a+1, 0};
    return res[a % 4];
}

int getXor(int a, int b) {
    return f(b) ^ f(a);
}