Array of Pairs of ပေးထားသော၎င်းတွင်ရှိရှိသမျှ Symmetric Pairs ကိုရှာပါ


ခက်ခဲအဆင့် လွယ်ကူသော
မကြာခဏမေးတယ် အမေဇုံ Capgemini Cisco သည် FreeCharge Moonfrog ဓာတ်ခွဲခန်း တေးသံစုံကဇါတ် Xome
အခင်းအကျင်း hash

အားလုံးသောအချိုးကျအတွဲများကိုရှာပါ အခင်းအကျင်း။ သငျသညျအထဲတွင်အချိုးကျသောအားလုံးအတွက်ထွက်ရှာရန်ရှိသည်။ အတွဲလိုက် (a, b) နှင့် (c, d) အတွဲများက 'b' သည် 'c' နှင့် 'a' သည် 'd' နှင့်ညီမျှသော (1) တွင်အချိုးကျသောစုံတွဲကိုအချိုးကျသည်ဟုဆိုသည်။ , 2) (2, 1) ၏အချိုးကျ pair တစုံဖြစ်ပါတယ်။

နမူနာ

Array of Pairs of ပေးထားသော၎င်းတွင်ရှိရှိသမျှ Symmetric Pairs ကိုရှာပါ

{{11, 20},{30,40},{4,5},{5,4},{40,30}}
(4, 5) (30, 40)

အားလုံးအချိုးကျအားလုံးရှာဖွေရန် Algorithm

  1. a) ကြေညာပါ HashMap.
  2. စဉ် i <n (ခင်းကျင်းသည့်အရှည်)
    1. အစုံ ပထမ [i] [0] နှင့်ခင်းကျင်းရန် ဒုတိယ [i] [1] ဆိုက်ရောက်ရန်။
    2. secondValue ၏တန်ဖိုးသည် null မဟုတ်ပါ၊ secondValue ၏တန်ဖိုးသည် firstValue နှင့်ညီမျှမှုရှိမရှိစစ်ဆေးပါ
    3. အမှန်ဖြစ်ပါက secondValue နှင့် firstValue ကို print ထုတ်ပါ။
    4. Else သည် firstValue နှင့်ဒုတိယ Value ကို Hashmap သို့ထည့်သည်။
  3. ကွင်းဆက်တည်ရှိသည်အထိ a မှ d အထိဖြစ်စဉ်ကိုပြန်လုပ်ပါ။

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

ကျနော်တို့ခင်းကျင်းထားသောအတွဲများကိုပေးထားပြီး၎င်းအတွင်း၌အချိုးကျသောအရာအချို့တည်ရှိသည်။ ပြstatementနာကဖော်ပြသည်မှာကျွန်ုပ်တို့သည် array တစ်ခုအတွင်းရှိအချိုးကျသောအတွဲများအားလုံးကိုရှာဖွေရန်ဖြစ်သည်။ Loops နှစ်ခုကိုသုံးပြီး Array နှစ်ခုလုံးကိုတစ်ကြောင်းချင်းစီဖြတ်သန်းနိုင်သည်။ သို့သော်၎င်းသည်ကျွန်ုပ်တို့အားအချိန်ရှုပ်ထွေးမှုပိုများစေပြီးကျွန်ုပ်တို့တွင်ထိရောက်သောကုဒ်မရှိပါ။ ထို့နောက်ကျွန်ုပ်တို့သည်ပိုမိုကောင်းမွန်သောချဉ်းကပ်မှုကိုအသုံးပြုရန်အထူးအစီအစဉ်တစ်ခုတွင်ပထမ ဦး ဆုံးစီစစ်ရန်ကြိုးစားသော်လည်းကျွန်ုပ်တို့၏ထိရောက်မှုကိုလိုအပ်သည် ထိရောက်တဲ့ program တစ်ခုရဖို့အတွက် hashing ကိုသုံးရမယ်။

hashmap ကိုအသုံးပြုခြင်းအားဖြင့်ကျွန်ုပ်တို့သည်ပထမ ဦး ဆုံး pair တစုံ၏ element ကိုသိုလှောင်ထားသည် ပထမ နှင့် pair တစုံရဲ့ဒုတိယဒြပ်စင် ဒုတိယ, ကျွန်တော်တို့က pair တစုံ၏ဒြပ်စင်နှစ်ခုလုံးကိုသော့နှင့်တန်ဖိုးတစ်ခုအဖြစ်အသုံးပြုနိုင်သည်။ ကျွန်ုပ်တို့သည်အတွဲတစ်ခု၏သော့ကိုအခြားစုံတွဲတစ်တွဲ၏တန်ဖိုးနှင့်တူညီသောအတွဲ၏တန်ဖိုးနှင့်အခြားစုံတွဲ၏သော့နှင့်နှိုင်းယှဉ်ခြင်းအားဖြင့်၎င်းကိုမြေပုံတွင်ရှာဖွေလိမ့်မည်

ကျွန်တော်တို့ဟာ hashmap ကိုအသုံးပြုမည်။ အတွဲစုံပေးထားသောဥပမာတစ်ခုကိုစဉ်းစားကြစို့။ ၎င်းတွင်ရှိ Symmetric Pairs အားလုံးကိုရှာပါ။

နမူနာ

arr={{1, 2},{30,40},{6,9},{2,1},{9,6}}

array ရဲ့ array တန်ဖိုးတွေကို firstValue နဲ့ secondValue ထဲမှာသိမ်းထားပြီးပြီဆိုရင်ကျွန်တော်တို့စစ်ဆေးပါမယ်။

i = 0,

firstValue = arr [i] [0] // pair တစုံ 1st element

secondValue = arr [i] [1] // pair တစုံ 2nd ဒြပ်စင်

firstValue = 1, secondValue = 2

၎င်းသည်မြေပုံတွင်တန်ဖိုးနှင့်မှားနေပါက 1 ကိုစစ်ဆေးပါမည်။ ထိုတန်ဖိုးနှစ်ခုလုံးကိုမြေပုံထဲသို့ထည့်ပါ။

မြေပုံ = [{၁: ၂}]

i = 1,

firstValue = arr [i] [0] // pair တစုံ 1st element

secondValue = arr [i] [1] // pair တစုံ 2nd ဒြပ်စင်

firstValue = 30, secondValue = 40

၎င်းသည်မြေပုံတွင်တန်ဖိုးနှင့်မှားနေပါက 30 ကိုစစ်ဆေးပါမည်။ ထိုတန်ဖိုးနှစ်ခုလုံးကိုမြေပုံထဲသို့ထည့်ပါ။

မြေပုံ = [{၁: ၂}၊ {၃၀:၄၀}]

i = 2,

firstValue = arr [i] [0] // pair တစုံ 1st element

secondValue = arr [i] [1] // pair တစုံ 2nd ဒြပ်စင်

firstValue = 6, secondValue = 9

၎င်းသည်မြေပုံတွင်တန်ဖိုးနှင့်မှားနေပါက 6 ကိုစစ်ဆေးပါမည်။ ထိုတန်ဖိုးနှစ်ခုလုံးကိုမြေပုံထဲသို့ထည့်ပါ။

Map=[{1:2},{30:40},{6:9}]

i = 3,

firstValue = arr [i] [0] // pair တစုံ 1st element

secondValue = arr [i] [1] // pair တစုံ 2nd ဒြပ်စင်

firstValue = 2, secondValue = 1

မြေပုံတွင်တန်ဖိုးရှိလျှင် ၁ ကိုစစ်ဆေးမည်၊ ၎င်းသည် '1' အဖြစ်တည်ရှိပါကဒုတိယဗယ်လီ၏ element သည် firstValue နှင့်ညီမျှပြီး၎င်းအခြေအနေသည်လည်းကျေနပ်မှုရှိမရှိစစ်ဆေးသည်။

ဒါကြောင့်ငါတို့ (1, 2) ပုံနှိပ်ထုတ်ဝေ

Map=[{1:2},{30:40},{6:9}]

i = 4,

firstValue = arr [i] [0] // pair တစုံ 1st element

secondValue = arr [i] [1] // pair တစုံ 2nd ဒြပ်စင်

firstValue = 9, secondValue = 6

မြေပုံတွင်၎င်းတည်ရှိမှုရှိမရှိနှင့်၎င်းကို '6' အဖြစ်တည်ရှိပါက၊ ၆ ကိုစစ်ဆေးပါမည်၊ ဒုတိယတန်ဖိုး၏ element သည် firstValue နှင့်ညီသည်၊ ဤအခြေအနေသည်ကျေနပ်မှုရှိမရှိစစ်ဆေးပါမည်။

ဒါကြောင့် (၁၊ ၂)၊ (၆၊ ၉) ကိုပုံနှိပ်တယ်။

Map=[{1:2},{30:40},{6:9}]

ကုဒ်

အချိုးကျစွမ်းအားလုံးကိုရှာဖွေရန် C ++ အစီအစဉ်

#include<unordered_map>
#include<iostream>
using namespace std;
void getSymmetricPair(int arr[][2], int row)
{
    unordered_map<int, int> myMap;

    for (int i = 0; i < row; i++)
    {
        int firstValue = arr[i][0];
        int secondValue = arr[i][1];

        if (myMap.find(secondValue) != myMap.end() && myMap[secondValue] == firstValue)
        {
            cout << "(" << secondValue << ", " << firstValue << ")"<<" ";
        }
        else
        {
            myMap[firstValue] = secondValue;
        }
    }
}
int main()
{
    int arr[5][2]= {{11,20},{30,40},{4,5},{5,4},{40,30}};
    getSymmetricPair(arr, 5);
}
(4, 5) (30, 40)

အချိုးကျစုံအားလုံးအတွက်ရှာရန် Java Program

import java.util.HashMap;
class pairSymmetrics
{
    static void getSymmetricPair(int arr[][])
    {
        HashMap<Integer, Integer> hashmap = new HashMap<Integer, Integer>();

        for (int i = 0; i < arr.length; i++)
        {
            int firstValue = arr[i][0];
            int secondValue = arr[i][1];
            Integer val = hashmap.get(secondValue);

            if (val != null && val == firstValue)
            {
                System.out.print("(" + secondValue + ", " + firstValue + ")" + " ");
            }
            else
            {
                hashmap.put(firstValue, secondValue);
            }
        }
    }

    public static void main(String arg[])
    {
        int arr[][]= {{11,20},{30,40},{4,5},{5,4},{40,30}};
        getSymmetricPair(arr);

    }
}
(4, 5) (30, 40)

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

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

အို (ဎ) ဘယ်မှာ “ n” သည် array ထဲရှိ element အရေအတွက်ဖြစ်သည်။ ကျွန်ုပ်တို့ HashMap ကိုအသုံးပြုပြီးကတည်းကသွင်းခြင်း၊ ဖျက်ခြင်း / ရှာဖွေခြင်းကိုလုပ်ဆောင်နိုင်သည် အို (၁) အချိန်။

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

အို (ဎ) ဘယ်မှာ “ n” သည် array ထဲရှိ element အရေအတွက်ဖြစ်သည်။ ကျွန်ုပ်တို့သည်မြေပုံထဲတွင်ဒြပ်စင်များကိုသိမ်းဆည်းပြီးကတည်းက အဆိုပါအာကာသရှုပ်ထွေး linear ဖြစ်ပါတယ်။

ကိုးကား