पहली घटना द्वारा आदेशित ऐरे तत्वों की समूह एकाधिक घटना


कठिनाई स्तर आसान
में अक्सर पूछा एकोलाइट एडोब वीरांगना Delhivery चौपाई
ऐरे हैश

आपको एक प्रश्न दिया जाता है जिसमें आपने एक अनसोल्ड दिया है सरणी संख्याओं की कई घटनाओं के साथ। कार्य सरणी तत्वों के सभी कई घटनाओं को पहली घटना द्वारा आदेशित करना है। इस बीच, नंबर आने पर ऑर्डर समान होना चाहिए।

उदाहरण

इनपुट:

[२, ३,४,३,१,३,२,४]

आउटपुट:

[२ २ ३ ३ ३ ३ ४ १]

इनपुट:

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

आउटपुट:

[२ २ ३ ३ ३ ३ ४ १]

कलन विधि

  1. एलान हैश मैप.
  2. सरणी को पार करें और सभी तत्वों और इसकी आवृत्ति को हाशप में डालें।
  3. सरणी को ट्रेस करते समय और प्रत्येक तत्व की आवृत्ति प्राप्त करें।
    1. उस फ़्रीक्वेंसी समय तक उस कुंजी को प्रिंट करें।
    2. उस गिरफ्तार को हटा दें [i] (कुंजी)।

ऐरे एलिमेंट्स के ग्रुप मल्टीपल क्यूरेशन के लिए स्पष्टीकरण

हम इसके लिए हैशिंग का उपयोग करने जा रहे हैं। हाशिंग तत्वों को कुंजी-मूल्य जोड़ी के रूप में संग्रहीत करने की सुविधा प्रदान करता है। इस प्रश्न में, हम एक एरे तत्व के रूप में एक कुंजी और प्रत्येक तत्व की आवृत्ति के रूप में एक मूल्य का उपयोग करने जा रहे हैं। हम तत्व को सम्मिलित करते हैं यदि वह हैश तालिका में मौजूद नहीं है। तत्व की गिनती (की-वैल्यू) को बढ़ाएं।

सबसे पहले, हम एक हैशपेयर को "myMap" कहने की घोषणा करेंगे। हम फिर पूरी सरणी और गिनती और भंडारण करते हैं आवृत्ति प्रत्येक तत्व की।

आइए एक उदाहरण पर विचार करें और इसे समझें।

उदाहरण

गिरफ्तार = [५, ४, १, ५, ४, १, ५, ६]

i = 0, गिरफ्तारी [i] = 5

myMap = {5: 1}

i = 1, गिरफ्तारी [i] = 4

myMap = {4: 1,5: 1}

i = 2, गिरफ्तारी [i] = 1

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

i = 3, गिरफ्तारी [i] = 5

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

i = 4, गिरफ्तारी [i] = 4

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

i = 5, गिरफ्तारी [i] = 1

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

i = 6, गिरफ्तारी [i] = 5

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

i = 6, गिरफ्तारी [i] = 6

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

अब हमारे पास एक myMap और इसमें मूल्य होंगे।

एक सरणी में फिर से दिए गए तत्व के साथ एक सरणी को फिर से प्राप्त करने के बाद हम आवृत्ति प्राप्त करेंगे। प्रत्येक सरणी तत्व को अपनी आवृत्ति के साथ लेते हुए और उस आवृत्ति समय तक एक लूप बनाएं और आवृत्ति के समय तक सभी सरणी तत्वों को प्रिंट करने के बाद उस सरणी कुंजी को हटा दें ताकि यह आगे के ट्रैवर्सल में फिर से प्रिंट न हो।

अर्र [i] = ५ आवृत्ति = ३

5 मुद्रित किया जाएगा, 3 बार, फिर हम उस कुंजी को myMap में निकाल देंगे, इसलिए जब भी हम किसी सरणी में 5 पढ़ते हैं तो यह हैशमैप में मौजूद नहीं होगा और प्रिंट नहीं करता है।

अर्र [i] = ५ आवृत्ति = ३

4 मुद्रित किया जाएगा, 2 बार, myMap में कुंजी को हटा दिया जाएगा, इसलिए जब भी हम किसी सरणी में 4 पढ़ते हैं तो वह HashMap में मौजूद नहीं होगा और प्रिंट नहीं करता है।

अर्र [i] = ५ आवृत्ति = ३

1 मुद्रित किया जाएगा, 2 बार, फिर हम उस कुंजी को myMap में निकाल देंगे, इसलिए जब भी हम किसी सरणी में 5 पढ़ते हैं और यह HashMap में मौजूद नहीं होगा और प्रिंट नहीं करता है।

अब 5 सरणी में आता है, लेकिन यह HashMap में मौजूद नहीं होगा और ऐसा ही होता है और तब तक कुछ भी नहीं करते जब तक कि तत्व जो HashMap में मौजूद नहीं है।

Arr [i] = 6 आवृत्ति = 1

6 मुद्रित किया जाएगा, 1 बार, myMap में कुंजी को हटा दिया जाएगा, इसलिए जब भी हम सरणी में 4 पढ़ते हैं तो यह हैशमैप में मौजूद नहीं होगा और प्रिंट नहीं करता है।

हमारे पास अब 5 5 5 4 4 1 1 6 के रूप में आउटपुट होगा।

कार्यान्वयन

समूह ++ के लिए 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

जावा कार्यक्रम

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

एरे तत्वों के समूह एकाधिक घटना के लिए जटिलता विश्लेषण

समय जटिलता

पर) जहां "N" सरणी में तत्वों की संख्या है।

अंतरिक्ष जटिलता

पर) जहां "N" सरणी में तत्वों की संख्या है।

संदर्भ