ਦਿੱਤੇ ਗਏ ਐਰੇ ਵਿਚ ਡੁਪਲਿਕੇਟ ਲੱਭੋ ਜਦੋਂ ਤੱਤ ਇਕ ਸੀਮਾ ਤੱਕ ਸੀਮਿਤ ਨਾ ਹੋਣ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਸੌਖੀ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਅਡੋਬ ਐਮਾਜ਼ਾਨ ਤੱਥ ਮੈਕ UHG ਆਪਟਮ
ਅਰੇ ਹੈਸ਼ਿੰਗ

ਸਮੱਸਿਆ "ਜਦੋਂ ਦਿੱਤੇ ਤੱਤ ਇੱਕ ਸੀਮਾ ਤੱਕ ਸੀਮਿਤ ਨਹੀਂ ਹੁੰਦੇ ਤਾਂ ਇੱਕ ਦਿੱਤੇ ਐਰੇ ਵਿੱਚ ਡੁਪਲਿਕੇਟ ਲੱਭੋ" ਕਹਿੰਦਾ ਹੈ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਐਰੇ ਐਨ ਸ਼ਾਮਲ ਹੋਣ ਪੂਰਨ ਅੰਕ. ਜੇਕਰ ਇਹ ਐਰੇ ਵਿਚ ਮੌਜੂਦ ਹੈ ਤਾਂ ਡੁਪਲਿਕੇਟ ਤੱਤ ਲੱਭਣ ਲਈ ਸਮੱਸਿਆ ਬਿਆਨ ਕਰਦੀ ਹੈ. ਜੇ ਅਜਿਹਾ ਕੋਈ ਤੱਤ ਮੌਜੂਦ ਨਹੀਂ ਤਾਂ ਵਾਪਸੀ -1.

ਉਦਾਹਰਨ

ਦਿੱਤੇ ਗਏ ਐਰੇ ਵਿਚ ਡੁਪਲਿਕੇਟ ਲੱਭੋ ਜਦੋਂ ਤੱਤ ਇਕ ਸੀਮਾ ਤੱਕ ਸੀਮਿਤ ਨਾ ਹੋਣ

[ 2, 4, 6, 2, 7, 8, 9, 7]
2, 7

ਕਥਾ

ਇਸ ਐਰੇ ਵਿੱਚ 2 ਅਤੇ 7 ਸਿਰਫ ਡੁਪਲਿਕੇਟ ਤੱਤ ਹਨ.

[134, 567, 134, 456, 1000, 567, 7]
134, 567

ਕਥਾ

ਇਸ ਐਰੇ ਵਿੱਚ 134 ਅਤੇ 567 ਸਿਰਫ ਡੁਪਲਿਕੇਟ ਤੱਤ ਹਨ.

ਐਰੇ ਵਿੱਚ ਡੁਪਲਿਕੇਟ ਐਲੀਮੈਂਟਸ ਲੱਭਣ ਲਈ ਐਲਗੋਰਿਦਮ

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

ਕਥਾ

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

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

ਆਓ ਇੱਕ ਉਦਾਹਰਣ ਤੇ ਵਿਚਾਰ ਕਰੀਏ:

ਐਰ [] = {2,4,6,3,1,2,4,7};

i = 0, ਅਰਰ [i] = 2; freq = {2: 1

i=1, arr[i]=4; freq={2:1,4:1}

i=2, arr[i]=6; freq={2:1,4:1,6:1}

i=3, arr[i]=3; freq={2:1,4:1,6:1,3:1}

i=4, arr[i]=1; freq={2:1,4:1,6:1,3:1,1:1}

i = 5, ਅਰਰ [i] = 2; freq = {2: 2,4: 1,6: 1,3: 1,1: 1} // '2' ਦੀ ਬਾਰੰਬਾਰਤਾ ਨੂੰ 1 ਤੋਂ ਵਧਾ ਕੇ 2,

i = 6, ਅਰਰ [i] = 4; freq = {2: 2,4: 2,6: 1,3: 1,1: 1} // '4' ਦੀ ਬਾਰੰਬਾਰਤਾ ਨੂੰ 1 ਤੋਂ ਵਧਾ ਕੇ 2,

i=7, arr[i]=7; freq={2:2,4:2,6:1,3:1,1:1,7:1}

ਸਾਡੇ ਕੋਲ ਨਕਸ਼ੇ ਵਿਚ ਫ੍ਰੀਕ ਹੈ: {2: 2,4: 2,6: 1,3: 1,1: 1,7: 1}

ਹੁਣ ਨਕਸ਼ੇ 'ਤੇ ਦੁਹਰਾਓ, ਅਤੇ ਇਹ ਪਤਾ ਲਗਾਓ ਕਿ ਕਿਹੜੀ ਵੈਲਯੂ ਦੀ ਬਾਰੰਬਾਰਤਾ 1 ਤੋਂ ਵੱਧ ਹੈ. ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਇਥੇ ਬੁਲੀਅਨ ਵੇਰੀਏਬਲ ਡੁਪਲਿਕੇਟ ਨੂੰ ਗਲਤ ਕਰਾਰ ਦਿੱਤਾ ਹੈ, ਇਸ ਲਈ ਜਦੋਂ ਅਸੀਂ ਜਾਂਚ ਕਰਦੇ ਹਾਂ ਕਿ ਕਿਹੜੀ ਬਾਰੰਬਾਰਤਾ 1 ਤੋਂ ਵੱਧ ਹੈ ਤਾਂ ਅਸੀਂ ਡੁਪਲਿਕੇਟ ਨੂੰ ਸਹੀ ਦੇ ਰੂਪ ਵਿੱਚ ਅਪਡੇਟ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ. ਅਤੇ ਜੇ ਅਸੀਂ ਡੁਪਲਿਕੇਟ ਨੂੰ ਗਲਤ ਕਹਿ ਕੇ ਲੂਪ ਵਿਚੋਂ ਬਾਹਰ ਆ ਜਾਂਦੇ ਹਾਂ, ਤਾਂ ਇਸਦਾ ਅਰਥ ਹੈ ਕਿ ਇਕ ਐਰੇ ਵਿਚ ਡੁਪਲਿਕੇਟ ਐਲੀਮੈਂਟ ਮੌਜੂਦ ਨਹੀਂ ਹੈ.

ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ, 2 ਅਤੇ 4 ਦੀ ਇਕ ਬਾਰੰਬਾਰਤਾ ਹੈ ਮਤਲਬ ਤੋਂ ਕਿ ਉਹ ਡੁਪਲਿਕੇਟ ਤੱਤ ਹਨ.

ਅਤੇ ਸਾਡੀ ਆਉਟਪੁੱਟ [2 4] ਬਣ ਜਾਂਦੀ ਹੈ. ਤਾਂ ਇਹ ਇਸਦੀ ਇੱਕ ਉਦਾਹਰਣ ਸੀ ਕਿ ਕਿਵੇਂ ਅਸੀਂ ਇੱਕ ਐਰੇ ਵਿੱਚ ਡੁਪਲਿਕੇਟ ਤੱਤ ਲੱਭਦੇ ਹਾਂ.

ਕੋਡ

ਐਰੇ ਵਿੱਚ ਡੁਪਲਿਕੇਟ ਤੱਤ ਲੱਭਣ ਲਈ ਸੀ ++ ਕੋਡ

#include <iostream>
#include <unordered_map>

using namespace std;

void getDuplicate(int arr[], int n)
{
    unordered_map<int,int> freq;

    for(int index=0;index<n;index++)
        freq[arr[index]]++;

    bool duplicate=false;
    unordered_map<int,int> :: iterator itr;
    for(itr=freq.begin();itr!=freq.end();itr++)
    {
        if(itr->second > 1)
        {
            cout<<itr->first<<" ";
            duplicate=true;
        }
    }
    if(!duplicate)
        cout<<"-1"<<endl;
}
int main()
{
    int arr[]={2,4,6,3,1,2,4,7};
    int n=sizeof(arr)/sizeof(arr[0]);
    getDuplicate(arr,n);
    return 0;
}
4 2

ਐਰੇ ਵਿੱਚ ਡੁਪਲਿਕੇਟ ਐਲੀਮੈਂਟਸ ਲੱਭਣ ਲਈ ਜਾਵਾ ਕੋਡ

import java.util.HashMap;
class findDuplicateNumber
{
    public static void getDuplicate(int arr[], int n)
    {
        HashMap<Integer, Integer> freq=new HashMap<Integer, Integer>();
        for(int i=0; i<n; i++)
        {
            if(freq.containsKey(arr[i]))
            {
                freq.put(arr[i],freq.get(arr[i])+1);
            }
            else
            {
                freq.put(arr[i],1);
            }
        }
        boolean duplicate=false;
        for(int i:freq.keySet())
        {
            if(freq.get(i)> 1)
            {
                System.out.print(i+" ");
                duplicate=true;
            }
        }
        if(!duplicate)
            System.out.println("-1");
    }
    public static void main(String [] args)
    {
        int arr[]= {2,4,6,3,1,2,4,7};
        int len=arr.length;
        getDuplicate(arr,len);
    }
}
2 4

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

ਟਾਈਮ ਜਟਿਲਤਾ

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

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

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