ਐਲੀਮੈਂਟਸ ਲੱਭੋ ਜੋ ਪਹਿਲੇ ਐਰੇ ਵਿੱਚ ਮੌਜੂਦ ਹਨ ਅਤੇ ਦੂਜੀ ਵਿੱਚ ਨਹੀਂ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਸੌਖੀ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਇਕੱਤਰ ਦਿੱਲੀ ਵਾਸੀ ਤੱਥ ਕੱਟੜਪੰਥੀ Snapdeal ਜੋਹੋ
ਅਰੇ ਹੈਸ਼

ਸਮੱਸਿਆ "ਉਹ ਤੱਤ ਲੱਭੋ ਜੋ ਪਹਿਲੇ ਐਰੇ ਵਿੱਚ ਮੌਜੂਦ ਹਨ ਅਤੇ ਦੂਜੀ ਵਿੱਚ ਨਹੀਂ" ਦੱਸਦੀ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਦੋ ਦਿੱਤੇ ਗਏ ਹਨ ਐਰੇ. ਐਰੇ ਵਿਚ ਸਾਰੇ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ ਪੂਰਨ ਅੰਕ. ਤੁਹਾਨੂੰ ਉਹ ਨੰਬਰ ਲੱਭਣੇ ਪੈਣਗੇ ਜੋ ਦੂਜੀ ਐਰੇ ਵਿਚ ਨਹੀਂ ਪਰ ਪਹਿਲੇ ਐਰੇ ਵਿਚ ਮੌਜੂਦ ਹੋਣਗੇ.

ਉਦਾਹਰਨ

ਐਲੀਮੈਂਟਸ ਲੱਭੋ ਜੋ ਪਹਿਲੇ ਐਰੇ ਵਿੱਚ ਮੌਜੂਦ ਹਨ ਅਤੇ ਦੂਜੀ ਵਿੱਚ ਨਹੀਂ

a [] = {2,4,3,1,5,6}
b [] = {2,1,5,6}
4 3
a [] ={4,2,6,8,9,5}
b [] ={9,3,2,6,8}
4

ਐਲਗੋਰਿਥਮ

  1. ਘੋਸ਼ਣਾ ਏ ਹੈਸ਼ਸੈੱਟ.
  2. ਐਰੇ ਬੀ [] ਦੇ ਸਾਰੇ ਤੱਤ ਹੈਸ਼ਸੈੱਟ ਵਿੱਚ ਪਾਓ.
  3. ਜਦੋਂ ਕਿ ਮੈਂ <l1 (ਇੱਕ ਐਰੇ ਦੀ ਲੰਬਾਈ a []).
    1. ਜੇ ਹੈਸ਼ਸੈੱਟ ਵਿੱਚ ਐਰੇ [i] ਨਹੀਂ ਹੈ, ਤਾਂ ਇੱਕ [i] ਪ੍ਰਿੰਟ ਕਰੋ.

ਕਥਾ

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

ਅਸੀ ਐਰੇ b [] ਨੰਬਰਸ ਨੂੰ ਹੈਸ਼ਸੈੱਟ ਵਿੱਚ ਪਾਉਣ ਜਾ ਰਹੇ ਹਾਂ ਅਤੇ ਐਰੇ ਬੀ ਦੀ ਸਾਰੀ ਨੰਬਰ ਪਾਉਣ ਤੋਂ ਬਾਅਦ []। ਅਸੀਂ ਇੱਕ ਐਰੇ ਨੂੰ ਟ੍ਰਾਵਰ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ [ਅਤੇ ਹਰ ਇੱਕ ਤੱਤ ਨੂੰ ਇੱਕ ਸਮੇਂ ਲੈ ਕੇ ਜਾਵਾਂਗੇ ਕਿ ਹੈਸ਼ਸੈੱਟ ਵਿੱਚ ਉਹ ਤੱਤ ਨਹੀਂ ਹਨ. ਜੇ ਇਸ ਵਿਚ ਉਹ ਤੱਤ ਨਹੀਂ ਹੈ, ਅਸੀਂ ਐਰੇ [i] ਦੇ ਉਸ ਖ਼ਾਸ ਤੱਤ ਨੂੰ ਛਾਪਣ ਜਾ ਰਹੇ ਹਾਂ ਅਤੇ ਕਿਸੇ ਹੋਰ ਨੰਬਰ ਦੀ ਜਾਂਚ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ.

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

ਪਹਿਲੀ ਐਰੇ ਹੈ [] = a [] = 2,6,8,9,5,4 9,5,2,6,8}, ਬੀ [] = {XNUMX}

ਸਾਨੂੰ ਐਰੇ ਬੀ []] ਦੇ ਸਾਰੇ ਤੱਤ ਹੈਸ਼ਸੈੱਟ ਵਿੱਚ ਪਾਉਣੇ ਹਨ, ਇਸ ਲਈ ਹੈਸ਼ਸੇਟ ਵਿੱਚ, ਸਾਡੇ ਕੋਲ ਹੇਠਾਂ ਮੁੱਲ ਹਨ:

ਹੈਸ਼ਸੈੱਟ: {9,5,2,6,8} // ਅਸਲ ਵਿੱਚ ਬੀ ਦੇ ਸਾਰੇ ਮੁੱਲ [].

ਅਰੇ ਏ [] ਨੂੰ ਪਾਰ ਕਰ ਜਾਵਾਂਗੇ ਅਤੇ ਇਸਦੇ ਹਰ ਤੱਤ ਨੂੰ ਲੈ ਕੇ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕਰਾਂਗੇ.

i = 0, ਏ [i] = 2

2 ਹੈਸ਼ਸੈੱਟ ਵਿਚ ਹੈ, ਇਸ ਲਈ ਇਹ ਪ੍ਰਿੰਟ ਨਹੀਂ ਹੋਏਗੀ.

i = 1, ਏ [i] = 6

6 ਹੈਸ਼ਸੈੱਟ ਵਿਚ ਹੈ, ਦੁਬਾਰਾ ਇਸ ਨੂੰ ਪ੍ਰਿੰਟ ਨਹੀਂ ਕੀਤਾ ਜਾਵੇਗਾ.

i = 2, ਏ [i] = 8

8 ਹੈਸ਼ਸੈੱਟ ਵਿਚ ਹੈ, ਇਹ ਪ੍ਰਿੰਟ ਨਹੀਂ ਕੀਤੀ ਜਾਏਗੀ.

i = 3, ਏ [i] = 9

9 ਹੈਸ਼ਸੈੱਟ ਵਿਚ ਹੈ, ਇਸ ਲਈ ਇਹ ਪ੍ਰਿੰਟ ਨਹੀਂ ਹੋਏਗੀ.

i = 4, ਏ [i] = 5

5 ਹੈਸ਼ਸੈੱਟ ਵਿਚ ਹੈ, ਦੁਬਾਰਾ ਇਸ ਨੂੰ ਪ੍ਰਿੰਟ ਨਹੀਂ ਕੀਤਾ ਜਾਵੇਗਾ.

i = 5, ਏ [i] = 4

4 ਹੈਸ਼ਸੈੱਟ ਵਿਚ ਨਹੀਂ ਹੈ, ਇਸ ਲਈ ਇਸ ਵਾਰ ਇਸ ਨੂੰ ਛਾਪਿਆ ਜਾਵੇਗਾ ਭਾਵ ਇਹ ਉਹ ਨੰਬਰ ਹੈ ਜੋ ਇਕ ਐਰੇ ਵਿਚ ਮੌਜੂਦ ਹੈ []] ਪਰ ਐਰੇ ਬੀ ਵਿਚ ਨਹੀਂ [ਕਿਉਂਕਿ ਅਸਲ ਵਿਚ ਹੈਸ਼ਸੈੱਟ ਐਰੇ ਬੀ ਦਾ ਕਲੋਨ ਹੈ [] ਅਤੇ ਸਾਡੀ ਆਉਟਪੁੱਟ ਆਵੇਗੀ '4' ਬਣ.

ਐਲੀਮੈਂਟ ਨੂੰ ਲੱਭਣ ਲਈ ਸੀ ++ ਕੋਡ ਜੋ ਪਹਿਲੇ ਐਰੇ ਵਿੱਚ ਮੌਜੂਦ ਹਨ ਅਤੇ ਸਕਿੰਟ ਵਿੱਚ ਨਹੀਂ

#include<unordered_set>
#include<iostream>
using namespace std;

void getMissingElement(int A[], int B[], int l1, int l2)
{
  unordered_set <int> myset;

  for (int i = 0; i < l2; i++)
    myset.insert(B[i]);

  for (int j = 0; j < l1; j++)
    if (myset.find(A[j]) == myset.end())
      cout << A[j] << " ";
}
int main()
{
    int a[] = { 9, 2, 3, 1, 4, 5 };
    int b[] = { 2, 4, 1, 9 };
  int l1 = sizeof(a) / sizeof(a[0]);
  int l2 = sizeof(b) / sizeof(b[0]);
  getMissingElement(a, b, l1, l2);
  return 0;
}
3 5

ਜਾਵਾ ਕੋਡ ਨੂੰ ਐਲੀਮੈਂਟਸ ਲੱਭਣ ਲਈ ਜੋ ਪਹਿਲੇ ਐਰੇ ਵਿੱਚ ਮੌਜੂਦ ਹਨ ਅਤੇ ਦੂਜੇ ਵਿੱਚ ਨਹੀਂ

import java.util.HashSet;
import java.util.Set;

class missingElement
{
    public static void getMissingElement(int A[], int B[])
    {
        int l1 = A.length;
        int l2 = B.length;

        HashSet<Integer> set = new HashSet<>();
        for (int i = 0; i < l2; i++)
            set.add(B[i]);

        for (int i = 0; i < l1; i++)
            if (!set.contains(A[i]))
                System.out.print(A[i]+" ");
    }
    public static void main(String []args)
    {
        int a[] = { 9, 2, 3, 1, 4, 5 };
        int b[] = { 2, 4, 1, 9 };

        getMissingElement(a, b);
    }
}
3 5

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

ਟਾਈਮ ਜਟਿਲਤਾ

ਓ (ਐਨ) ਜਿੱਥੇ ਕਿ “ਐਨ” ਐਰੇ 1 ਵਿੱਚ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਹੈ. ਕਿਉਂਕਿ ਸ਼ਾਮਲ ਕਰਨ ਅਤੇ ਖੋਜ ਕਰਨ ਲਈ ਹੈਸ਼ਸੈੱਟ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸਾਨੂੰ ਓਪਰੇਸ਼ਨ ਵਿਚ ਇਹ ਓਪਰੇਸ਼ਨ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ. ਇਸ ਪ੍ਰਕਾਰ ਸਮੇਂ ਦੀ ਗੁੰਝਲਤਾ ਰੇਖੀ ਹੁੰਦੀ ਹੈ.

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

ਓ (ਐਨ) ਜਿੱਥੇ ਕਿ “ਐਨ” ਐਰੇ 1 ਵਿੱਚ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਹੈ. ਕਿਉਂਕਿ ਅਸੀਂ ਦੂਜੀ ਐਰੇ ਦੇ ਤੱਤ ਸਟੋਰ ਕਰ ਰਹੇ ਹਾਂ. ਇਸ ਤਰ੍ਹਾਂ ਲੋੜੀਂਦੀ ਜਗ੍ਹਾ ਦੂਜੀ ਐਰੇ ਦੇ ਆਕਾਰ ਦੇ ਸਮਾਨ ਹੈ.