ആദ്യ അറേയിൽ ഉള്ളതും രണ്ടാമത്തേതുമായ ഘടകങ്ങൾ കണ്ടെത്തുക


വൈഷമ്യ നില എളുപ്പമായ
പതിവായി ചോദിക്കുന്നു അക്കോലൈറ്റ് ദില്ലി ഫാക്റ്റ്സെറ്റ് ഫനാറ്റിക്സ് സ്നാപ്ഡേൽ Zoho
അറേ ഹാഷ്

“ആദ്യ അറേയിൽ ഉള്ളതും രണ്ടാമത്തേതുമായ ഘടകങ്ങൾ കണ്ടെത്തുക” എന്ന പ്രശ്നം നിങ്ങൾക്ക് രണ്ട് നൽകിയിട്ടുണ്ടെന്ന് പറയുന്നു ശ്രേണികൾ. അറേകൾ എല്ലാം ഉൾക്കൊള്ളുന്നു പൂർണ്ണസംഖ്യകൾ. രണ്ടാമത്തെ അറേയിൽ‌ ഇല്ലെങ്കിലും ആദ്യത്തെ അറേയിൽ‌ അടങ്ങിയിരിക്കുന്ന അക്കങ്ങൾ‌ നിങ്ങൾ‌ കണ്ടെത്തണം.

ഉദാഹരണം

ആദ്യ അറേയിൽ ഉള്ളതും രണ്ടാമത്തേതുമായ ഘടകങ്ങൾ കണ്ടെത്തുക

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] പ്രിന്റുചെയ്യുക.

വിശദീകരണം

ഞങ്ങൾ രണ്ട് ഇന്റീരിയർ അറേകളും ഒരു പ്രശ്ന പ്രസ്താവനയും നൽകി, അത് ആദ്യ അറേയിൽ ഉള്ള സംഖ്യ കണ്ടെത്താൻ ആവശ്യപ്പെടുന്നു, രണ്ടാമത്തെ അറേയിലല്ല. ഞങ്ങൾ ഉപയോഗിക്കാൻ പോകുന്നു ഹാഷിംഗ് ഈ പ്രശ്‌നത്തിൽ. ഹാഷിംഗ് പരിഹാരം കാര്യക്ഷമമായി കണ്ടെത്താൻ ഞങ്ങളെ സഹായിക്കുന്നു.

ഞങ്ങൾ അറേ ബി [] നമ്പറുകൾ ഒരു ഹാഷ്‌സെറ്റിൽ ഇടാൻ പോകുന്നു, ഒപ്പം എല്ലാ അറേ ബി [] ഉം ചേർത്തതിനുശേഷം. ഞങ്ങൾ അറേ [ അതിന് ആ ഘടകം ഇല്ലെങ്കിൽ, ഞങ്ങൾ അറേയുടെ ഒരു പ്രത്യേക ഘടകം [i] അച്ചടിച്ച് മറ്റൊരു നമ്പറിനായി പരിശോധിക്കാൻ പോകുന്നു.

നമുക്ക് ഒരു ഉദാഹരണം പരിഗണിച്ച് ഇത് മനസിലാക്കാം:

ആദ്യ അറേ ഒരു [] = a [] = {2,6,8,9,5,4}, ബി [] = {9,5,2,6,8 is

അറേ ബി [] ന്റെ എല്ലാ ഘടകങ്ങളും ഹാഷ്‌സെറ്റിലേക്ക് ഉൾപ്പെടുത്തണം, അതിനാൽ ഹാഷ്‌സെറ്റിൽ ഞങ്ങൾക്ക് ഇനിപ്പറയുന്ന മൂല്യങ്ങളുണ്ട്:

ഹാഷ്‌സെറ്റ്:, 9,5,2,6,8} // അടിസ്ഥാനപരമായി b യുടെ എല്ലാ മൂല്യങ്ങളും [].

ഞങ്ങൾ അറേ ഒരു [] സഞ്ചരിച്ച് അതിന്റെ ഓരോ ഘടകങ്ങളും എടുത്ത് അവസ്ഥ പരിശോധിക്കും.

i = 0, a [i] = 2

2 ഹാഷ്‌സെറ്റിലാണ്, അതിനാൽ ഇത് അച്ചടിക്കില്ല.

i = 1, a [i] = 6

6 ഹാഷ്‌സെറ്റിലാണ്, വീണ്ടും അച്ചടിക്കില്ല.

i = 2, a [i] = 8

8 ഹാഷ്‌സെറ്റിലാണ്, അത് അച്ചടിക്കില്ല.

i = 3, a [i] = 9

9 ഹാഷ്‌സെറ്റിലാണ്, അതിനാൽ ഇത് അച്ചടിക്കില്ല.

i = 4, a [i] = 5

5 ഹാഷ്‌സെറ്റിലാണ്, വീണ്ടും അച്ചടിക്കില്ല.

i = 5, a [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

സങ്കീർണ്ണത വിശകലനം

സമയ സങ്കീർണ്ണത

O (N) എവിടെ "N" അറേ 1 ലെ ഘടകങ്ങളുടെ എണ്ണം. ഉൾപ്പെടുത്തലിനും തിരയലിനുമായി ഹാഷ്‌സെറ്റ് ഉപയോഗിക്കുന്നത് O (1) ൽ ഈ പ്രവർത്തനങ്ങൾ നടത്താൻ ഞങ്ങളെ അനുവദിക്കുന്നു. അങ്ങനെ സമയ സങ്കീർണ്ണത രേഖീയമാണ്.

ബഹിരാകാശ സങ്കീർണ്ണത

O (N) എവിടെ "N" അറേ 1 ലെ ഘടകങ്ങളുടെ എണ്ണം. രണ്ടാമത്തെ അറേയിലെ ഘടകങ്ങൾ ഞങ്ങൾ സംഭരിക്കുന്നതിനാൽ. അതിനാൽ ആവശ്യമായ ഇടം രണ്ടാമത്തെ അറേയുടെ വലുപ്പത്തിന് തുല്യമാണ്.