အကွာအဝေး၏အကြီးမြတ်ဆုံးထူးဆန်း Divisor ၏ XOR အပေါ်မေးမြန်းမှု


ခက်ခဲအဆင့် အလယ်အလတ်
မကြာခဏမေးတယ် 24 * 7 တီထွင်မှု Labs Citadel နေခြည် Expedia Google တကယ်ပါပဲ Snapdeal
အခင်းအကျင်း bits Bitwise-XOR ပြeryနာပြ.နာ

ပြProbleနာဖော်ပြချက်

ပြ “နာ“ အကွာအဝေး၏အကြီးမြတ်ဆုံးထူးကဲသောခွဲစိတ်မှု၏ XOR အပေါ်မေးမြန်းမှုများ” ကသင့်အားပေးထားသည်ဟုဖော်ပြသည် အခင်းအကျင်း of ကိန်း နှင့် query q, တစ်ခုချင်းစီကိုစုံစမ်းမှုတစ်ခုအကွာအဝေးပါဝင်ပါသည်။ အဆိုပါပြstatementနာကိုကြေညာချက်တစ်ခုချင်းစီကို query ကိုများအတွက်ပေးထားသောအကွာအဝေးအတွင်းအကြီးမြတ်ဆုံးထူးဆန်း Divisor ၏ XOR ထွက်ရှာရန်မေးတယ်။

နမူနာ

arr[] = {2, 6, 4}
Query :(1, 2), (0, 1)
2 2

ရှင်းလင်းချက်

အကြီးမြတ်ဆုံးထူးဆန်းကွဲပြားခြင်း: (1,3,1)

၃.၁ ရဲ့ XOR က ၂ ။

၃.၁ ရဲ့ XOR က ၂ ။

အကွာအဝေး၏အကြီးမြတ်ဆုံးထူးဆန်း Divisor ၏ XOR အပေါ်မေးမြန်းမှု

 

algorithm

  1. ပေးထားသောခင်းကျင်းဖြတ်သန်း။
    1. array တစ်ခု၏လက်ရှိ element ကိုထူးဆန်းလျှင်စစ်ဆေးပြီးအနည်းဆုံး divisor နံပါတ်ဖြင့်လက်ရှိ element ကို update လုပ်ပါ။
    2. အဆိုပါ Set မြတ်နိုး ပေးထားသောခင်းကျင်း၏ update ကိုဒြပ်စင်မှဒြပ်စင်။
  2. နောက်တဖန် array ကိုဖြတ်သန်းနှင့်တစ် ဦး ချင်းစီဒြပ်စင်ကို update မြတ်နိုး လက်ရှိဒြပ်စင်၏ XOR နှင့် divArray ခင်းကျင်းမှု၏မူလဒြပ်စင်ဖြစ်သည်။
  3. ဘယ်ဘက် element က 0 နဲ့ညီလားဆိုတာစစ်ဆေးပါ။ divArray [right] ကိုပြန်ပေးပါ။
  4. ကျန်သည် divArray [right] နှင့် divArray [left-1] ၏ XOR ကိုပြန်ပို့ပါ။

ရှင်းလင်းချက်

ကျနော်တို့ကိန်းဂဏန်းများနှင့်အချို့သောမေးခွန်းများကိုဖြေရှင်းပေးနိုင်သည်။ ထို့နောက်ကျွန်ုပ်တို့သည်အကြီးမြတ်ဆုံးထူးကဲသော divisor ၏ XOR ကိုရှာရန်တောင်းဆိုသည်။ အဆိုပါမေးမြန်းချက်နှစ်ခုကိန်းပါရှိသည်။ ဆိုလိုတာကဒီကိန်းနှစ်ခုအတွင်းမှာအကွာအဝေးရှိတယ်။ ၎င်းအတွက်ပထမ ဦး ဆုံးအနေဖြင့်နံပါတ်တစ်ခုစီ၏ divisors အားလုံးကိုရှာပြီး array ကိုဖြတ်သန်းနေမည်။ ပြီးရင်ကျွန်တော်တို့ကပေးထားတဲ့ခင်းကျင်းခြင်းမှနံပါတ်တစ်ခုကိုကောက်တော့မယ်။ အထူးသဖြင့်ပေးထားသော element အတွက် loop တစ်ခုစတင်ပါမည်။ ကွင်းဆက်တွင်ကျွန်ုပ်တို့သည်လက်ရှိဒြပ်စင်ကို ၂ ဖြင့် ဆက်၍ ဒြပ်စင်အထဲ၌အသစ်ပြောင်းမည်။ လက်ရှိဒြပ်စင်ကိုထူးဆန်းသည်ဟုမတွေ့ရှိမချင်းဤအရာသည်ဆက်လက်တည်ရှိလိမ့်မည်။ နံပါတ်ကိန်းဂဏန်းတွေဖြစ်လာတော့မယ်၊

array တစ်ခု၏ element တစ်ခုစီ၏လမ်းကြောင်းတစ်ခုစီအတွက်ရလဒ်ကိုတွန်းပါ မြတ်နိုး ကထူးဆန်းဖြစ်လာဘယ်မှာခင်းကျင်း, ။ ပေးထားသောခင်းကျင်းချက်တွင်ရှိသည့်အတိုင်းတူညီသောဒြပ်စင်တစ်ခုရှိလိမ့်မည်။ ဒါပေမယ့် divisors တွေအားလုံး divArray ထဲမှာရှိပါတယ်။ array ပြီးသည်နှင့် divisors အားလုံးသိမ်းဆည်းထားသော array ကိုဖြတ်သွားပါ။ ထို့ကြောင့်တန်ဖိုးအားလုံးကိုသိုလှောင်ထားသည့် divArray ခင်းကျင်းမှုသည်ခွဲဝေသူဖြစ်သည်။ ထိုအခါကျွန်ုပ်တို့သည် divArray တန်ဖိုးများပေါ်တွင် XOR စစ်ဆင်ရေးကိုလုပ်ဆောင်တော့မည်။ ကျွန်ုပ်တို့သည် divArray ကိုဖြတ်သွားမည်။ XOR သည်လက်ရှိ element နှင့် array ၏ယခင် element တို့ဖြစ်သည်။ ထို့အပြင်ဤအရာအားလုံးကို pair တစုံစီတိုင်းအတွက်လက်ရှိနှင့်ယခင်တန်ဖိုးအနေဖြင့်လုပ်ဆောင်သည့်တိုင်အောင်ပြုလုပ်သင့်သည်။

ဒါကြောင့်ကျနော်တို့ကအကွာအဝေး, left နှင့်ညာအဖြစ်စုံစမ်းမှုကိုပေးသောအခါ။ ပြီးရင်ဘယ်ဘက်ကသုညနဲ့ညီမလားဆိုတာစစ်ဆေးကြည့်ရအောင်။ ထို့နောက် divArray [right] သို့ပြန်သွားပါ။ သို့မဟုတ်ပါက divArray [right] နှင့် divArray [left-1] ကို XOR သို့ပြန်သွားပါမည်။

ကုဒ်

အကွာအဝေး၏အကြီးမြတ်ဆုံးထူးဆန်းပိုင်းခြား၏ XOR အပေါ်မေးမြန်းချက်များကိုဖြေဆိုရန် C ++ ကုဒ်

#include<iostream>

using namespace std;

void getDivisorArray(int arr[], int divArray[], int n)
{
    for (int i = 0; i < n; i++)
    {
        while (arr[i] % 2 != 1)
            arr[i] /= 2;

        divArray[i] = arr[i];
    }
    for (int i = 1; i < n; i++)
        divArray[i] = divArray[i - 1] ^ divArray[i];
}

int solveQuery(int divArray[], int left, int right)
{
    if (left == 0)
        return divArray[right];
    else
        return divArray[right] ^ divArray[left - 1];
}

int main()
{
    int arr[] = {2, 6, 4};
    int n = sizeof(arr) / sizeof(arr[0]);

    int divArray[n];
    getDivisorArray(arr, divArray, n);

    cout << solveQuery(divArray, 1, 2) << endl;
    cout << solveQuery(divArray, 0, 1) << endl;

    return 0;
}
2
2

အကွာအဝေး၏အကြီးမြတ်ဆုံးထူးဆန်း divisor ၏ XOR အပေါ် Queries အပေါ်ဖြေဆိုရန် Java ကုဒ်

class QueriesXOR
{
    public static void getDivisorArray(int arr[], int divArray[], int n)
    {
        for (int i = 0; i < n; i++)
        {
            while (arr[i] % 2 != 1)
                arr[i] /= 2;

            divArray[i] = arr[i];
        }
        for (int i = 1; i < n; i++)
            divArray[i] = divArray[i - 1] ^ divArray[i];
    }
    
    static int solveQuery(int divArray[], int l, int r)
    {
        if (l == 0)
            return divArray[r];
        else
            return divArray[r] ^ divArray[l - 1];
    }
    
    public static void main (String[] args)
    {
        int arr[] = {2, 6, 4};
        int n = arr.length;

        int divArray[] = new int[n];
        getDivisorArray(arr, divArray, n);

        System.out.println(solveQuery(divArray, 1, 2)) ;
        System.out.println (solveQuery(divArray, 0, 1));
    }
}
2
2

ရှုပ်ထွေးဆန်းစစ်ခြင်း

အချိန်ရှုပ်ထွေး

အို (N log n) ဘယ်မှာ "N" သည် array အတွင်းရှိ element အရေအတွက်ဖြစ်သည်။ ပြီးတော့ သည်ခင်းကျင်းပြသမှုတွင်ပါ ၀ င်သောနံပါတ်သည်အခြေ 2 ဖြစ်သည်။ log n factor သည်ကိန်းဂဏန်းများကိုခွဲခြမ်းခြင်းအားဖြင့်ကျွန်ုပ်တို့သည်ထူးကဲသော divisor ကိုရရှိသည်အထိဖြစ်သည်။

အာကာသရှုပ်ထွေးမှု

အို (N) ဘယ်မှာ "N" သည် array အတွင်းရှိ element အရေအတွက်ဖြစ်သည်။ အာကာသကိုယူနေသော xor တန်ဖိုးများကိုသိမ်းဆည်းရန်ကျွန်ုပ်တို့သည် array တစ်ခုကိုအသုံးပြုခဲ့သည်။