ပထမ ဦး ဆုံးဖြစ်ပျက်မှုကအမိန့် Array ကို Element တွေကို၏အုပ်စုအလိုက် Multiple ဖြစ်ပျက်မှု


ခက်ခဲအဆင့် လွယ်ကူသော
မကြာခဏမေးတယ် Accolite Adobe က အမေဇုံ ဒေလီ လေးကစ်
အခင်းအကျင်း hash

သင့်အားမဖော်ပြထားသောမေးခွန်းတစ်ခုကိုသင့်အားပေးထားပါသည် အခင်းအကျင်း နံပါတ်များကိုအများအပြားကွိနှင့်အတူ။ အဆိုပါတာဝန်ပထမ ဦး ဆုံးဖြစ်ပျက်မှုအားဖြင့်အမိန့်ပေးခဲ့သည်ခင်းကျင်းဒြပ်စင်အပေါငျးတို့သမျိုးစုံကွိအုပ်စုဖွဲ့ဖို့ဖြစ်ပါတယ်။ ဤအတောအတွင်းနံပါတ်အရေအတွက်ရောက်လာအဖြစ်အတူတူဖြစ်သင့်သည်။

နမူနာ

input:

[2, 3,4,3,1,3,2,4]

output:

[2 2 3 3 3 4 4 1]

input:

[5,4,1,5,4,1,5,6]

output:

[5 5 5 4 4 1 1 6]

algorithm

  1. ကြွေးကြော်ပါ HashMap.
  2. Array ကိုဖြတ်ပြီး element များနှင့်၎င်း၏ကြိမ်နှုန်းအားလုံးကို HashMap ထဲသို့ထည့်ပါ။
  3. array ကိုဖြတ်သန်းပြီး element တစ်ခုစီ၏ကြိမ်နှုန်းကိုရယူနေစဉ်။
    1. ကြောင်းကြိမ်နှုန်းကြိမ်မှသော့ချက် print ထုတ်ပါ။
    2. ကြောင်း arr [i] (သော့) ဖယ်ရှားပါ။

Array Elements ၏အုပ်စုအလိုက်အကြိမ်များစွာဖြစ်ပေါ်မှုအတွက်ရှင်းလင်းချက်

Hashing ကိုသုံးမယ်။ Hashing သည် element များကို key-value pair အနေဖြင့်သိုလှောင်သိမ်းဆည်းထားသည့်အင်္ဂါရပ်တစ်ခုဖြစ်သည်။ ဤမေးခွန်းတွင်ကျွန်ုပ်တို့သည်သော့ကို array element တစ်ခုအဖြစ်အသုံးပြုပြီးတန်ဖိုးတစ်ခုစီ၏ကြိမ်နှုန်းအဖြစ်အသုံးပြုမည်။ သူက hash table ထဲမှာမရှိရင် element ကိုထည့်လိုက်ရုံပါပဲ။ အခြား element ၏ count (value-value) ကိုတိုးမြှင့်ပါ။

ပထမ ဦး စွာ hashMap ကို myMap ဟုကြေငြာမည်။ ပြီးရင် array တစ်ခုလုံးကိုဖြတ်ပြီးရေတွက်ခြင်းနှင့်သိုလှောင်ခြင်း အကြိမ်ရေ တစ်ခုချင်းစီကိုဒြပ်စင်၏။

ဥပမာတစ်ခုကိုလေ့လာပြီး၎င်းကိုနားလည်ကြပါစို့။

နမူနာ

arr = [၅၊ ၄၊ ၁၊ ၅၊ ၄၊ ၁၊ ၅၊ ၆]

ဈ = 0, ဆိုက်ရောက် [i] = 5

myMap = {၅: ၁}

ဈ = 1, ဆိုက်ရောက် [i] = 4

myMap = {4: 1,5: 1}

ဈ = 2, ဆိုက်ရောက် [i] = 1

myMap = {1: 1,4: 1,5: 1}

ဈ = 3, ဆိုက်ရောက် [i] = 5

myMap = {1: 1,4: 1,5: 2}

ဈ = 4, ဆိုက်ရောက် [i] = 4

myMap = {1: 1,4: 2,5: 2}

ဈ = 5, ဆိုက်ရောက် [i] = 1

myMap = {1: 2,4: 2,5: 2}

ဈ = 6, ဆိုက်ရောက် [i] = 5

myMap = {1: 2,4: 2,5: 3}

ဈ = 6, ဆိုက်ရောက် [i] = 6

myMap={1:2,4:2,5:3,6:1}

ယခုတွင်၎င်းတွင် myMap နှင့်တန်ဖိုးများရှိလိမ့်မည်။

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

Arr [ဈ] = 5 ကြိမ်နှုန်း = 3

5 ကိုပုံနှိပ်ထုတ်ဝေမည်။ 3 ကြိမ်၊ ထို့နောက်ထို key ကို myMap တွင်ဖယ်ရှားလိမ့်မည်။ 5 ကို array ထဲ၌ဖတ်ပါက hashmap တွင် မရှိ၍ print မလုပ်ပါ။

Arr [ဈ] = 4 ကြိမ်နှုန်း = 2

4 ကိုပုံနှိပ်ထုတ်ဝေမည်, 2 ကြိမ်, key ကို myMap တွင်ဖယ်ရှားလိမ့်မည်, ဒါကြောင့်ကျနော်တို့က 4 ခင်းကျင်းမှုတွင်ဖတ်ပါအခါတိုင်းက HashMap တွင်ပစ္စုပ္ပန်မည်မဟုတ်ပါပုံနှိပ်မထားဘူး။

Arr [ဈ] = 1 ကြိမ်နှုန်း = 2

၁ ကို ၂ ပုံ ၂ ပုံနှိပ်ပြီးရင်အဲဒီ key ကို myMap ထဲမှာဖယ်ထုတ်မှာပါ။ ၅ ကို array ထဲမှာဖတ်တိုင်း HashMap မှာမရှိဘူး၊ print မထုတ်ဘူး။

အခု 5 ကို array ထဲထည့်လိုက်ပြီ။ ဒါပေမယ့် HashMap မှာမရှိတော့ဘူး။ HashMap မှာရှိနေတဲ့ element ကိုမတွေ့မချင်းဘာမှမလုပ်ဘူး။

Arr [ဈ] = 6 ကြိမ်နှုန်း = 1

6 ကိုပုံနှိပ်ပါလိမ့်မည်, တစ်ကြိမ်, myMap တွင်သော့ကိုဖယ်ရှားလိမ့်မည်, ဒါကြောင့်ကျနော်တို့ခင်းကျင်း 1 ဖတ်ပါအခါတိုင်းသူ hashmap တွင်မပါလိမ့်မယ်နှင့် print ထုတ်မထားဘူး။

အခုဆိုရင် 5 5 5 4 4 1 1 6 အဖြစ် output ကိုရပါလိမ့်မယ်။

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

ပထမအကြိမ်ထပ်ခါထပ်ခါပြုလုပ်ခြင်းဖြင့်အမိန့်ပေးသောအုပ်စုမျိုးစုံထပ်ခါထပ်ခါဖြစ်ပေါ်ခြင်းအစုများအတွက် C ++ အစီအစဉ်

#include<iostream>
#include<unordered_map>

using namespace std;
void arrangeInOrder(int arr[], int n)
{
    unordered_map<int, int> myMap;

    for (int i=0; i<n; i++)
    {
        myMap[arr[i]]++;
    }
    for (int i=0; i<n; i++)
    {
        int count = myMap[arr[i]];
        for (int j=0; j<count; j++)
            cout<<arr[i]<< " ";

        myMap.erase(arr[i]);
    }
}
int main()
{
    int arr[] = {10, 5, 3, 10, 10, 4, 1, 3};
    int n=sizeof(arr)/sizeof(arr[0]);
    arrangeInOrder(arr,n);
    return 0;
}
10 10 10 5 3 3 4 1

Java ပရိုဂရမ်

import java.util.HashMap;

class multipleOccurences
{
    public static void arrangeInOrder(int arr[])
    {
        HashMap<Integer, Integer> myMap= new HashMap<Integer, Integer>();

        for (int i=0; i<arr.length; i++)
        {
            Integer current = myMap.get(arr[i]);
            if (current == null)
                current = 0;

            myMap.put(arr[i], current + 1);
        }
        for (int i=0; i<arr.length; i++)
        {
            Integer count = myMap.get(arr[i]);
            if (count != null)
            {
                for (int j=0; j<count; j++)
                {
                    System.out.print(arr[i] + " ");
                }
                myMap.remove(arr[i]);
            }
        }
    }
    public static void main (String[] args)
    {
        int arr[] = {10, 5, 3, 10, 10, 4, 1, 3};
        arrangeInOrder(arr);
    }
}
10 10 10 5 3 3 4 1

Array Element များအုပ်စုအကြိမ်ပေါင်းများစွာဖြစ်ပွားမှုများအတွက်ရှုပ်ထွေးခွဲခြမ်းစိတ်ဖြာ

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

အို (ဎ) ဘယ်မှာ “ n” သည် array အတွင်းရှိ element အရေအတွက်ဖြစ်သည်။

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

အို (ဎ) ဘယ်မှာ “ n” သည် array အတွင်းရှိ element အရေအတွက်ဖြစ်သည်။

အညွှန်း