வரிசை நிகழ்வுகளின் குழு பல நிகழ்வுகள் முதல் நிகழ்வால் கட்டளையிடப்படுகின்றன


சிரமம் நிலை எளிதாக
அடிக்கடி கேட்கப்படுகிறது அகோலைட் அடோப் அமேசான் Delhivery ஃபோர்கைட்டுகள்
அணி ஹாஷ்

நீங்கள் வரிசைப்படுத்தப்படாத ஒரு கேள்வியைக் கொடுத்துள்ளீர்கள் வரிசை எண்களின் பல நிகழ்வுகளுடன். முதல் நிகழ்வால் வரிசைப்படுத்தப்பட்ட வரிசை உறுப்புகளின் பல நிகழ்வுகளை குழுவாக்குவதே பணி. இதற்கிடையில், ஆர்டர் எண் வருவதைப் போலவே இருக்க வேண்டும்.

உதாரணமாக

உள்ளீடு:

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

வெளியீடு:

[2 2 3 3 3 4 4 1]

உள்ளீடு:

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

வெளியீடு:

[5 5 5 4 4 1 1 6]

அல்காரிதம்

  1. அறிவிக்க ஹாஷ்மேப்.
  2. வரிசைக்குச் சென்று அனைத்து உறுப்புகளையும் அதன் அதிர்வெண்ணையும் ஹாஷ்மேப்பில் வைக்கவும்.
  3. வரிசையை கடந்து செல்லும்போது ஒவ்வொரு உறுப்பின் அதிர்வெண்ணையும் பெறுங்கள்.
    1. அந்த அதிர்வெண் நேரங்கள் வரை அந்த விசையை அச்சிடுக.
    2. அந்த arr [i] (விசை) ஐ அகற்று.

வரிசை கூறுகளின் குழு பல நிகழ்வுகளுக்கான விளக்கம்

அதற்காக நாங்கள் ஹாஷிங்கைப் பயன்படுத்தப் போகிறோம். உறுப்புகளை ஒரு முக்கிய மதிப்பு ஜோடியாக சேமிக்கும் அம்சத்தை ஹாஷிங் வழங்குகிறது. இந்த கேள்வியில், ஒரு விசையை ஒரு வரிசை உறுப்பாகவும் ஒரு மதிப்பை ஒவ்வொரு தனிமத்தின் அதிர்வெண்ணாகவும் பயன்படுத்தப் போகிறோம். உறுப்பு ஹாஷ் அட்டவணையில் இல்லாவிட்டால் அதை வெறுமனே செருகுவோம். வேறு உறுப்புகளின் எண்ணிக்கையை (விசை மதிப்பு) அதிகரிக்கவும்.

முதலில், ஒரு ஹாஷ்மேப் “மைமேப்” என்று அறிவிப்போம். நாங்கள் முழு வரிசையையும் கடந்து, எண்ணி சேமித்து வைக்கிறோம் அதிர்வெண் ஒவ்வொரு உறுப்புக்கும்.

ஒரு உதாரணத்தைக் கருத்தில் கொண்டு அதைப் புரிந்துகொள்வோம்.

உதாரணமாக

arr = [5, 4, 1, 5, 4, 1, 5, 6]

i = 0, arr [i] = 5

myMap = {5: 1}

i = 1, arr [i] = 4

myMap = {4: 1,5: 1}

i = 2, arr [i] = 1

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

i = 3, arr [i] = 5

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

i = 4, arr [i] = 4

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

i = 5, arr [i] = 1

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

i = 6, arr [i] = 5

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

i = 6, arr [i] = 6

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

இப்போது அதில் ஒரு மைமேப் மற்றும் மதிப்புகள் இருக்கும்.

ஒரு வரிசையில் வரிசைப்படுத்தப்பட்ட உறுப்புடன் மீண்டும் ஒரு வரிசையை கடந்து சென்ற பிறகு அதிர்வெண் கிடைக்கும். ஒவ்வொரு வரிசை உறுப்புகளையும் அதன் அதிர்வெண்ணுடன் எடுத்து, அந்த அதிர்வெண் நேரம் வரை மற்றும் அனைத்து வரிசை கூறுகளையும் அச்சிட்ட பிறகு அதிர்வெண் நேரங்கள் அந்த வரிசை விசையை அகற்றும் வரை அது மேலும் பயணத்தில் மீண்டும் அச்சிடாது.

அர் [i] = 5 அதிர்வெண் = 3

5 அச்சிடப்படும், 3 முறை, பின்னர் அந்த விசையை மைமேப்பில் அகற்றுவோம், எனவே 5 இல் ஒரு வரிசையில் படிக்கும் போதெல்லாம் அது ஹாஷ்மாப்பில் இருக்காது மற்றும் அச்சிடாது.

அர் [i] = 4 அதிர்வெண் = 2

4 அச்சிடப்படும், 2 முறை, விசை மைமேப்பில் அகற்றப்படும், எனவே நாம் ஒரு வரிசையில் 4 ஐப் படிக்கும்போதெல்லாம் அது ஹாஷ்மேப்பில் இருக்காது மற்றும் அச்சிடாது.

அர் [i] = 1 அதிர்வெண் = 2

1 அச்சிடப்படும், 2 முறை, பின்னர் அந்த விசையை மைமேப்பில் அகற்றுவோம், எனவே 5 ஐ ஒரு வரிசையில் படிக்கும்போதெல்லாம் அது ஹாஷ்மேப்பில் இருக்காது மற்றும் அச்சிடாது.

இப்போது 5 வரிசையில் வருகிறது, ஆனால் அது ஹாஷ்மேப்பில் இருக்காது, அதேபோல் நடக்கும் மற்றும் ஹாஷ்மேப்பில் இருக்கும் உறுப்பு கண்டுபிடிக்கப்படும் வரை எதுவும் செய்யாது.

அர் [i] = 6 அதிர்வெண் = 1

6 அச்சிடப்படும், 1 முறை, விசை மைமேப்பில் அகற்றப்படும், எனவே நாம் வரிசையில் 4 ஐப் படிக்கும்போதெல்லாம் அது ஹாஷ்மாப்பில் இருக்காது மற்றும் அச்சிடாது.

இப்போது வெளியீட்டை 5 5 5 4 4 1 1 6 ஆகக் கொண்டிருப்போம்.

நடைமுறைப்படுத்தல்

வரிசை நிகழ்வுகளின் குழு பல நிகழ்வுகளுக்கான சி ++ நிரல் முதல் நிகழ்வால் ஆர்டர் செய்யப்பட்டது

#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” என்பது வரிசையில் உள்ள உறுப்புகளின் எண்ணிக்கை.

விண்வெளி சிக்கலானது

ஓ (n) எங்கே “N” என்பது வரிசையில் உள்ள உறுப்புகளின் எண்ணிக்கை.

குறிப்பு