ਐਰੇ ਵਿੱਚ ਦੁਹਰਾਇਆ ਚੋਟੀ ਦੇ ਤਿੰਨ ਲੱਭੋ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਸੌਖੀ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਮੈਕ o9 ਹੱਲ ਵਿਪਰੋ
ਅਰੇ ਹੈਸ਼

ਸਮੱਸਿਆ "ਐਰੇ ਵਿੱਚ ਦੁਹਰਾਓ ਚੋਟੀ ਦੇ ਤਿੰਨ ਲੱਭੋ" ਕਹਿੰਦੀ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਇੱਕ ਦਿੱਤਾ ਗਿਆ ਹੈ ਐਰੇ ਇਸ ਵਿਚ ਕੁਝ ਦੁਹਰਾਵ ਵਾਲੀਆਂ ਸੰਖਿਆਵਾਂ ਦੇ ਨਾਲ n ਸੰਖਿਆਵਾਂ ਦੀ. ਤੁਹਾਡਾ ਕੰਮ ਇਕ ਐਰੇ ਵਿਚ ਚੋਟੀ ਦੇ 3 ਦੁਹਰਾਏ ਨੰਬਰਾਂ ਦਾ ਪਤਾ ਲਗਾਉਣਾ ਹੈ.

ਉਦਾਹਰਨ

ਐਰੇ ਵਿੱਚ ਦੁਹਰਾਇਆ ਚੋਟੀ ਦੇ ਤਿੰਨ ਲੱਭੋ

[1,3,4,6,7,2,1,6,3,10,5,7]
1 3 6

ਕਥਾ

ਇੱਥੇ 1,3 ਅਤੇ 6 ਦੋ ਵਾਰ ਦੁਹਰਾਇਆ ਗਿਆ ਹੈ.

[2,4,2,1,5,6,8,5,3,9,0,1]
1 2 5

ਕਥਾ

ਇੱਥੇ 1,2 ਅਤੇ 5 ਦੋ ਵਾਰ ਦੁਹਰਾਇਆ ਗਿਆ ਹੈ.

ਚੋਟੀ ਦੇ ਤਿੰਨ ਦੁਹਰਾਏ ਤੱਤ ਲੱਭਣ ਲਈ ਐਲਗੋਰਿਦਮ

  1. ਦਾ ਐਲਾਨ ਫੋਲਡਰ ਨੂੰ ਅਤੇ ਉਪਭੋਗਤਾ ਦੁਆਰਾ ਪ੍ਰਭਾਸ਼ਿਤ ਕਲਾਸ ਨੂੰ ਪੇਅਰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ.
  2. ਵਾਪਸ ਆਓ ਜੇ ਘੱਟੋ ਘੱਟ ਤਿੰਨ ਮੁੱਲ ਮੌਜੂਦ ਨਾ ਹੋਣ.
  3. ਇੰਪੁੱਟ ਦੇ ਹਰੇਕ ਤੱਤ ਦੀ ਬਾਰੰਬਾਰਤਾ ਗਿਣੋ ਅਤੇ ਸਟੋਰ ਕਰੋ ਐਰੇ ਅਤੇ ਇਸ ਨੂੰ ਨਕਸ਼ੇ ਵਿੱਚ ਪਾਓ.
  4. ਜੋੜੀ ਸ਼੍ਰੇਣੀ ਦੇ ਆਬਜੈਕਟ ਬਣਾਓ ਅਤੇ ਇਸਨੂੰ ਪੂਰਨ ਅੰਕ ਦੇ ਘੱਟੋ ਘੱਟ ਮੁੱਲ ਨਾਲ ਆਰੰਭ ਕਰੋ.
  5. ਨਕਸ਼ਾ ਨੂੰ ਪਾਰ ਕਰਦੇ ਹੋਏ.
    1. ਜਾਂਚ ਕਰੋ ਕਿ ਮੌਜੂਦਾ ਕੁੰਜੀ ਦੀ ਬਾਰੰਬਾਰਤਾ ਨਿਰਧਾਰਤ ਆਬਜੈਕਟ ਨਾਲੋਂ ਵੱਧ ਹੈ.
    2. ਜੇ ਇਹ ਸਹੀ ਹੈ, ਤਦ ਸਾਰੀਆਂ ਕੁੰਜੀਆਂ ਅਤੇ ਮੁੱਲਾਂ ਨੂੰ ਪੇਅਰ ਦੇ ਹੋਰ ਆਬਜੈਕਟ ਤੇ ਸ਼ਿਫਟ ਕਰੋ.
  6. ਚੋਟੀ ਦੇ ਤਿੰਨ ਤੱਤ ਪ੍ਰਿੰਟ ਕਰੋ.

ਕਥਾ

ਸਾਨੂੰ ਇਸ ਵਿਚ ਸਟੋਰ ਕੀਤੇ ਕੁਝ ਪੂਰਨ ਅੰਕ ਦੇ ਨਾਲ ਐਰੇ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ. ਸਮੱਸਿਆ ਕਹਿੰਦੀ ਹੈ ਕਿ ਚੋਟੀ ਦੇ 3 ਦੁਹਰਾਏ ਤੱਤ ਲੱਭੋ. ਇਸ ਲਈ, ਸਾਡਾ ਮੁੱਖ ਵਿਚਾਰ ਹਰੇਕ ਤੱਤ ਦੀ ਬਾਰੰਬਾਰਤਾ ਨੂੰ ਗਿਣਨਾ ਅਤੇ ਸਟੋਰ ਕਰਨਾ ਹੈ. ਅਸੀਂ ਇਸ ਨੂੰ ਇਕ ਨਕਸ਼ੇ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕਰਾਂਗੇ. ਫਿਰ ਇਕ ਹੋਰ ਵਿਚਾਰ ਆਉਂਦਾ ਹੈ ਜੋ ਇਕ ਕਲਾਸ ਦਾ ਐਲਾਨ ਕਰਨਾ ਅਤੇ ਉਸ ਕਲਾਸ ਦੀਆਂ ਚੀਜ਼ਾਂ ਦੀ ਵਰਤੋਂ ਸਾਡੇ ਮੁੱਲ ਨੂੰ ਚੈੱਕ ਕਰਨ ਅਤੇ ਸਟੋਰ ਕਰਨ ਲਈ ਕਰਨਾ ਹੈ ਜੋ ਸਾਡੀ ਆਉਟਪੁੱਟ ਹੋ ਸਕਦੇ ਹਨ.

ਅਸੀਂ ਹਰੇਕ ਤੱਤ ਦੀ ਬਾਰੰਬਾਰਤਾ ਦੀ ਗਿਣਤੀ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ ਅਤੇ ਫਿਰ ਬਾਅਦ ਵਿੱਚ ਨਕਸ਼ੇ ਵਿੱਚ ਹਰ ਦੂਜੀ ਬਾਰੰਬਾਰਤਾ ਨਾਲ ਤੁਲਨਾ ਕਰਾਂਗੇ ਜੋ ਕਿ ਇੱਕ ਵੱਡੀ ਸੰਖਿਆ ਹੈ ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਤਿੰਨ ਹੋਰ ਸੰਖਿਆਵਾਂ ਵਿੱਚ ਵੱਡੀ ਨੰਬਰ ਲੱਭਣ ਲਈ ਵਰਤਦੇ ਹਾਂ.

ਆਓ ਇੱਕ ਉਦਾਹਰਣ ਤੇ ਵਿਚਾਰ ਕਰੀਏ ਅਤੇ ਇਸਨੂੰ ਸਮਝੀਏ.

ਅਰੁ [] = {9, 4, 2, 9, 1, 9, 15, 1, 15, 15, 1, 2, 9}

ਐਰੇ ਵਿੱਚ ਮੌਜੂਦ ਹਰੇਕ ਤੱਤ ਦੀ ਬਾਰੰਬਾਰਤਾ ਨੂੰ ਗਿਣਨ ਨਾਲ ਸ਼ੁਰੂ ਕਰਨਾ. ਅਸੀਂ ਇਕ ਨਕਸ਼ੇ ਦਾ ਨਿਰਮਾਣ ਕਰਾਂਗੇ ਜਿਸ ਵਿਚ, ਸਾਰੇ ਤੱਤ ਅਤੇ ਉਨ੍ਹਾਂ ਦੀਆਂ ਬਾਰੰਬਾਰਤਾਵਾਂ ਸਟੋਰ ਕੀਤੀਆਂ ਜਾਣਗੀਆਂ. ਸਾਡੇ ਨਕਸ਼ੇ ਵਿੱਚ ਹੇਠ ਲਿਖੀਆਂ ਕਦਰਾਂ ਕੀਮਤਾਂ ਹਨ:

Freq= {1:3, 2:2, 4:1, 9:4,15:3,9:4}

ਸਾਡੇ ਕੋਲ ਜੋ ਸਾਨੂੰ ਚਾਹੀਦਾ ਹੈ ਸਭ ਹੈ, ਇਸ ਸਭ ਵਿੱਚ ਸਾਨੂੰ ਸਿਰਫ ਚੋਟੀ ਦੀਆਂ 3 ਬਾਰ ਬਾਰ ਸੰਖਿਆਵਾਂ ਨੂੰ ਲੱਭਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ. ਇਸਦੇ ਲਈ, ਅਸੀਂ ਜੋੜ ਦੇ ਵਰਗ ਦੇ ਆਬਜੈਕਟਸ ਦੇ ਮੁੱਲ ਨੂੰ ਪੂਰਨ ਅੰਕ ਦੇ ਘੱਟੋ ਘੱਟ ਮੁੱਲ ਨਾਲ ਅਰੰਭ ਕਰਦੇ ਹਾਂ. ਅਸੀਂ ਹਰ ਕੁੰਜੀ ਅਤੇ ਉਨ੍ਹਾਂ ਦੀ ਬਾਰੰਬਾਰਤਾ ਨੂੰ ਪਾਰ ਕਰਾਂਗੇ. ਫਿਰ ਆਬਜੈਕਟ ਨਾਲ x.first, y.first, z.first ਦੀ ਤੁਲਨਾ ਕਰੋ. ਅਤੇ ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਐਰੇ ਵਿੱਚ ਚੋਟੀ ਦੇ 3 ਦੁਹਰਾਏ ਤੱਤ ਪ੍ਰਿੰਟ ਕਰਦੇ ਹਾਂ.

ਕੋਡ

ਐਰੇ ਵਿੱਚ ਦੁਹਰਾਇਆ ਚੋਟੀ ਦੇ ਤਿੰਨ ਨੂੰ ਲੱਭਣ ਲਈ ਸੀ ++ ਕੋਡ

#include <bits/stdc++.h>
using namespace std;
void getRepeatedNumbers(int arr[], int n)
{
    if (n < 3)
    {
        cout << "INVALID !! PLEASE ENTER CORRECT INPUT";
        return;
    }
    unordered_map<int, int> fre;
    for (int i = 0; i < n; i++)
        fre[arr[i]]++;

    pair<int, int> x, y, z;
    x.first = y.first = z.first = INT_MIN;

    for (auto val : fre)
    {
        if (val.second > x.first)
        {
            z = y;
            y = x;

            x.first = val.second;
            x.second = val.first;
        }
        else if (val.second > y.first)
        {
            z = y;

            y.first = val.second;
            y.second = val.first;
        }
        else if (val.second > z.first)
        {
            z.first = val.second;
            z.second = val.first;
        }
    }
    cout << "Top three repeated elements are  "<< x.second << " " << y.second<< " " << z.second;
}
int main()
{
    int arr[] = { 9, 4, 2, 9, 1, 9, 15, 1, 15, 15, 1, 2, 9 };
    int n = sizeof(arr) / sizeof(arr[0]);
    getRepeatedNumbers(arr, n);
    return 0;
}
Top three repeated elements are  9 15 1

ਐਰੇ ਵਿੱਚ ਦੁਹਰਾਇਆ ਚੋਟੀ ਦੇ ਤਿੰਨ ਨੂੰ ਲੱਭਣ ਲਈ ਜਾਵਾ ਕੋਡ

import java.io.*;
import java.util.*;

class Pair
{
    int first, second;
}
class topThreeRepeatedNumber
{
    public static void getRepeatedNumbers(int[] arr, int n)
    {
        if (n < 3)
        {
            System.out.print("INVALID !! PLEASE ENTER CORRECT INPUT");
            return;
        }
        TreeMap<Integer, Integer> freq = new TreeMap<>();

        for (int i = 0; i < n; i++)
        {
            if (freq.containsKey(arr[i]))
                freq.put(arr[i], 1 + freq.get(arr[i]));
            else
                freq.put(arr[i], 1);
        }

        Pair x = new Pair();
        Pair y = new Pair();
        Pair z = new Pair();
        x.first = y.first = z.first = Integer.MIN_VALUE;

        for (Map.Entry val : freq.entrySet())
        {
            if (Integer.parseInt(String.valueOf(val.getValue())) > x.first)
            {

                z.first = y.first;
                z.second = y.second;
                y.first = x.first;
                y.second = x.second;

                x.first = Integer.parseInt(String.valueOf(val.getValue()));
                x.second = Integer.parseInt(String.valueOf(val.getKey()));
            }
            else if (Integer.parseInt(String.valueOf(val.getValue())) > y.first)
            {
                z.first = y.first;
                z.second = y.second;

                y.first = Integer.parseInt(String.valueOf(val.getValue()));
                y.second = Integer.parseInt(String.valueOf(val.getKey()));
            }
            else if (Integer.parseInt(String.valueOf(val.getValue())) > z.first)
            {
                z.first = Integer.parseInt(String.valueOf(val.getValue()));
                z.second = Integer.parseInt(String.valueOf(val.getKey()));
            }
        }

        System.out.println("Top three repeated elements are " + x.second + ", "+ y.second + ", " + z.second);
    }
    public static void main(String args[])
    {
        int[] arr = { 9, 4, 2, 9, 1, 9, 15, 1, 15, 15, 1, 2, 9 };
        int n = arr.length;
        getRepeatedNumbers(arr, n);
    }
}
Top three repeated elements are 9, 1, 15

ਜਟਿਲਤਾ ਵਿਸ਼ਲੇਸ਼ਣ

ਟਾਈਮ ਜਟਿਲਤਾ

ਹੇ (n) ਜਿੱਥੇ ਕਿ “ਐਨ” ਐਰੇ ਵਿਚਲੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਹੈ. ਹਾਸ਼ਮੈਪ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਅਸੀਂ ਇੱਕ ਮਹੱਤਵਪੂਰਣ ਕਾਰਕ ਦੁਆਰਾ ਸਮੇਂ ਦੀ ਜਟਿਲਤਾ ਨੂੰ ਘਟਾਉਣ ਦੇ ਯੋਗ ਹੋ ਗਏ ਸੀ, ਜੋ ਕਿ ਸਮੱਸਿਆ ਨੂੰ "ਐਰੇ ਵਿੱਚ ਦੁਹਰਾਓ ਲੱਭੋ" ਰੇਖਿਕ ਬਣਾਉਂਦੇ ਹੋਏ.

ਸਪੇਸ ਦੀ ਜਟਿਲਤਾ

ਹੇ (n) ਜਿੱਥੇ ਕਿ “ਐਨ” ਐਰੇ ਵਿਚਲੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਹੈ. ਸਭ ਤੋਂ ਮਾੜੇ ਹਾਲਾਤ ਵਿੱਚ, ਅਸੀਂ n ਕੁੰਜੀ-ਮੁੱਲ ਦੇ ਜੋੜੇ ਸਟੋਰ ਕਰਾਂਗੇ. ਇਸ ਤਰ੍ਹਾਂ ਪੁਲਾੜ ਦੀ ਜਟਿਲਤਾ ਵੀ ਲੀਨੀਅਰ ਹੈ.