အမိန့်တူညီသောစောင့်ရှောက်မှုပေးထားသော Array နှစ်ခုမှအများဆုံး Array


ခက်ခဲအဆင့် အလယ်အလတ်
မကြာခဏမေးတယ် Accenture အမေဇုံ ဒေလီ အချက်အလက် လေးကစ် OYO အခန်းများ Publicis Sapient Zoho
အခင်းအကျင်း hash

ကျွန်တော်တို့မှာကိန်းနှစ်ခုရှိတယ်ဆိုပါစို့ အခင်းအကျင်း တူညီသောအရွယ်အစား n ။ Array နှစ်မျိုးလုံးတွင်ဘုံနံပါတ်များပါ ၀ င်နိုင်သည်။ ပြstatementနာကကြေငြာချက်သည်ရလဒ်နှစ်ခုလုံးမှ 'n' အမြင့်ဆုံးတန်ဖိုးများပါ ၀ င်သောထွက်ပေါ်လာသည့်ခင်းကျင်းမှုကိုဖွဲ့စည်းရန်တောင်းဆိုသည်။ ပထမ ဦး ဆုံးခင်းကျင်းမှုကို ဦး စားပေးသင့်သည် (ပထမ ဦး ဆုံးခင်းကျင်းထားသည့်အရာများသည်ပထမဆုံးထွက်ပေါ်လာသင့်သည်) output array သည်ပေးထားသော Array နှစ်ခုလုံးမှအများဆုံး element များဖြစ်သော်လည်း common element များတစ်ကြိမ် လာရောက်၍ array ကို ဦး စားပေးသင့်သည်။

နမူနာ

input:

int arr1 [] = {3,7,9,1,4}

int arr2 [] = {2,8,6,5,3}

output:

{7, 9, 8, 6, 5}

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

7, 9 အရပထမဆုံး array ထဲမှာ element တွေရှိတယ်၊ ဒါကြောင့် output ထဲကပထမဆုံးထွက်မယ်။

input:

int arr1 [] = {9,3,2}

int arr2 [] = {6,4,1}

output:

{9, 6, 4}

Order တူညီနေခြင်းကိုပေးထားသော Arrays နှစ်ခုမှအများဆုံး Array အတွက် Algorithm

  1. Array ကိုနှစ်မျိုးလုံးကိုပြောင်းပါ အားနည်းချက်ကို.
  2. အဆိုပါ virus သယ်ဆောင်နှစ် ဦး စလုံး non- တက်ပြီး sequence ကိုအတွက်စီပါ။
  3. vector နှစ်ခုလုံးကိုတစ်ပြိုင်တည်းဖြတ်သန်းပြီး element များ၏ကြိမ်နှုန်းနှင့်အတူနှစ် n နှစ်မျိုးလုံး၏ n ၏ကြီးမားသောတန်ဖိုးများကိုမြေပုံသို့တွန်းပါ။
  4. အသစ်တစ်ခုကိုအားနည်းချက်ကို "output ကို" ဖန်တီးပါ။
  5. တစ် ဦး ဘုံဒြပ်စင်ရှိမရှိစစ်ဆေးပါ မြေပုံ ပြီးတော့ array ထဲမှာပထမ ဦး ဆုံးအနေနဲ့ element ကို output vector ထဲသို့ထည့်ပါ။
  6. မြေပုံတွင်ဘုံဒြပ်စင်တစ်ခုရှိသလားစစ်ခင်းကျင်းမှုဒုတိယတွင်လည်းရှိမရှိစစ်ဆေးပါ၊ အကြိမ်ရေ ၁ ခုရှိသည့်သူတို့ကိုရွေးချယ်ပြီး၎င်းတို့ကို output vector ထဲသို့ထည့်ပါ။
  7. ထွက်ပေါ်လာတဲ့အားနည်းချက်ကို "output ကို" ပုံနှိပ်ပါ။

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

Array နှစ်ခုစလုံးကို vector ထဲသို့ပြောင်းပြီးအစဉ်လိုက်စီရန်။ ဒီနည်းနဲ့ Array နှစ်ခုလုံးရဲ့တန်ဖိုးတွေကို vector ထဲကိုရရှိနိုင်တယ်။ ဦး တည်ချက်က virus နှစ်ခုစလုံးမှာနံပါတ်တွေပိုများတယ်။ ဒါကြောင့် n ကိုရွေးလို့ရတယ် အများဆုံးအရေအတွက် အဆိုပါ Array ကိုနှစ်ခုလုံးကနေ။

ကျွန်ုပ်တို့လုပ်မည့်ဘုံဒြပ်စင်များကိစ္စကိုကိုင်တွယ်ရန်မှာ vectors နှစ်ခုစလုံးကိုတစ်ပြိုင်တည်းနှိုင်းယှဉ်ခြင်းနှင့် Array နှစ်ခုလုံးမှအမြင့်ဆုံးကိုရွေးခြင်းနှင့်၎င်းကိုအကြိမ်ရေနှင့်အတူမြေပုံထဲသို့ထည့်ခြင်းဖြင့်၎င်းသည်ဖြစ်နိုင်လျှင်မျက်စိကိုထိန်းသိမ်းနိုင်သည်။ သာမန်ဒြပ်စင်များဖြစ်လာလျှင် n အမြင့်ဆုံး element များကိုမြေပုံထဲသို့တွန်းပို့လိမ့်မည်။ အကယ်၍ element တစ်ခုကိုတစ်ကြိမ်ထက်ပိုပြီးတွေ့ရှိပါက ၄ င်းတို့၏ကြိမ်နှုန်းကိုတိုးမြှင့်သွားမည်ဖြစ်ပြီး၎င်းတို့သည်မြေပုံထဲတွင်အပိုဒြပ်စင်အဖြစ်ရေတွက်လိမ့်မည်မဟုတ်ပါ၊ ကြိမ်နှုန်း 2, 3 သို့မဟုတ်ထိုထက်ပိုအဖြစ်မှတ်သား .. ဒီတော့နောက်ပိုင်းတွင်ဖြတ်သန်းအတွက်ကျနော်တို့ကလျစ်လျူရှုနိုင်ပါတယ်နှင့်ပထမ ဦး ဆုံးခင်းကျင်း ဦး စားပေးနိုင်ပါတယ်။

ကျနော်တို့ arrays နှင့်မြေပုံနှစ်ခုလုံးဖြတ်သန်းသွားနေကြသည်။ ပထမ ဦး စွာကျွန်ုပ်တို့သည်မြေပုံနှင့်အတူပထမဆုံးခင်းကျင်းမှုကိုဖြတ်သန်းရန်လိုအပ်သည်။ အကယ်၍ မြေပုံတွင်တွေ့ရသောဘုံဒြပ်စင်များနှင့်ခင်းကျင်းခြင်းများရှိပါက၎င်းကိုထွက်ပေါ်လာသော vector သို့တွန်းထုတ်ရန်လိုအပ်သည်။ ပြီးရင်ဒုတိယ array ကိုသုံးမယ်။ ဘုံဒြပ်စင်ကိုလည်းရလဒ်ကနေသိမ်းဆည်းထားလို့ရတယ်။ ဒါကြောင့်ဒီမှာဒုတိယထပ်ကိန်းနဲ့မြေပုံကဒီ element မှာမြေပုံမှာ ၁ ကြိမ်ရှိသလားဆိုတာစစ်ဆေးမယ့်။ ထို့နောက်မှသာ၎င်းကိုဖြစ်ပေါ်လာသော vector သို့တွန်းပို့လိမ့်မည်။ နောက်ဆုံးဒီ vector ကို print ထုတ်ပါ။

အကောင်အထည်ဖော်ရေး

Order Arrays Keeping ပေးထားသော Arrays နှစ်ခုမှအများဆုံး Array အတွက် C ++ အစီအစဉ်

#include<iostream>
#include<unordered_map>
#include<vector>
#include<algorithm>

using namespace std;

void makeGreaterFirstArray(int A[], int B[], int n)
{
    vector<int> V1(A, A+n);
    vector<int> V2(B, B+n);
    sort(V1.begin(), V1.end(), greater<int>());
    sort(V2.begin(), V2.end(), greater<int>());

    unordered_map<int, int> MAP;
    int i = 0, j = 0;
    while (MAP.size() < n)
    {
        if (V1[i] >= V2[j])
        {
            MAP[V1[i]]++;
            i++;
        }
        else
        {
            MAP[V2[j]]++;
            j++;
        }
    }
    vector<int> output;
    for (int i = 0; i < n; i++)
        if (MAP.find(A[i]) != MAP.end())
            output.push_back(A[i]);

    for (int i = 0; i < n; i++)
        if (MAP.find(B[i]) != MAP.end() && MAP[B[i]] == 1)
            output.push_back(B[i]);

    for (int i = 0; i < n; i++)
        cout << output[i] << " ";
}
int main()
{
    int arr1[] = {3,7,9,1,4};
    int arr2[] = {2,8,6,5,3};
    int n = sizeof(arr1) / sizeof(arr1[0]);
    makeGreaterFirstArray(arr1, arr2, n);
    return 0;
}
7 9 8 6 5

Order Arrays Keeping Order နှစ်ခုထားရှိသော Maximum Array အတွက် Java အစီအစဉ်

import java.util.Collections;
import java.util.Vector;
import java.util.HashMap;
import java.util.Arrays;
import java.util.stream.Collectors;

class findsubarray
{
    public static void makeGreaterFirstArray(int []A, int []B, int n)
    {
        Vector<Integer> V1 = new Vector<>();
        Vector<Integer> V2 = new Vector<>();

        Integer[] I1 = Arrays.stream( A ).boxed().toArray( Integer[]::new );
        Integer[] I2 = Arrays.stream( B ).boxed().toArray( Integer[]::new );


        Collections.addAll(V1, I1);
        Collections.addAll(V2, I2);

        Collections.sort(V1, Collections.reverseOrder());
        Collections.sort(V2, Collections.reverseOrder());


        HashMap<Integer, Integer> MAP = new HashMap<Integer, Integer>();

        int i = 0, j = 0;
        while (MAP.size() < n)
        {
            if (V1.get(i) >= V2.get(j))
            {
                if(MAP.containsKey(V1.get(i)))
                {
                    MAP.put(V1.get(i), MAP.get(V1.get(i))+1);
                    i++;
                }
                else
                {
                    MAP.put(V1.get(i),1);
                    i++;
                }
            }
            else
            {
                if(MAP.containsKey(V2.get(j)))
                {
                    MAP.put(V2.get(j), MAP.get(V2.get(j))+1);
                    j++;
                }
                else
                {
                    MAP.put(V2.get(j),1);
                    j++;
                }
            }
        }
        Vector<Integer> output = new Vector<Integer>();

        for (int a = 0; a < n; a++)
            if (MAP.containsKey(A[a]))
                output.add(A[a]);

        for (int b = 0; b < n; b++)
            if (MAP.containsKey(B[b]) && MAP.get(B[b])==1)
                output.add(B[b]);


        System.out.println(output);
    }
    public static void main(String [] args)
    {
        int arr1[] = {3,7,9,1,4};
        int arr2[] = {2,8,6,5,3};
        int n = arr1.length;
        makeGreaterFirstArray(arr1, arr2, n);
    }
}
[7, 9, 8, 6, 5]

Order တူညီနေခြင်းကိုပေးထားသော Array နှစ်ခုမှအများဆုံး Array အတွက်ရှုပ်ထွေးမှုအားသုံးသပ်ခြင်း

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

အို (n log n) ဘယ်မှာ “ n” Array ကို၏အရှည်သည်။

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

အို (ဎ) ဘယ်မှာ “ n” Array ကို၏အရှည်သည်။