අරා දෙකක් සමානද නැද්ද යන්න පරීක්ෂා කරන්න  


දුෂ්කරතා මට්ටම මධ්යම
නිතර අසනු ලැබේ ඇක්සෙන්චර් ගෝල්ඩ්මන් සැක්ස් MAQ o9 විසඳුම් කුලී රථය ට්රිලිලියෝ
අරා හැෂ් වර්ග කිරීම

“අරා දෙකක් සමානද නැද්ද යන්න පරීක්ෂා කරන්න” යන ගැටලුවේ සඳහන් වන්නේ ඔබට දෙකක් ලබා දී ඇති බවයි අරා. ලබා දී ඇති අරා සමානද නැද්ද යන්න ඔබ විසින් තීරණය කළ යුතු බව ගැටළු ප්‍රකාශයේ සඳහන් වේ.

අරා දෙකක් සමානද නැද්ද යන්න පරීක්ෂා කරන්නපින්

උදාහරණයක්  

arr1[] = { 1, 4, 2, 5, 2 };
arr2[] = { 2, 1, 5, 4, 2 };
Yes, Arrays are equal !!
arr1[] = { 1, 3, 2, 7, 2 };
arr2[] = { 2, 1, 5, 3, 2 };
No, Arrays are not equal !!

අරා දෙකක් සමානද නැද්ද යන්න පරීක්ෂා කිරීමට ඇල්ගොරිතම  

  1. අරා දෙකේම දිග සකසන්න l1 සහ l2 පිළිවෙලින්.
  2. දිග දෙකම සමාන නොවේදැයි පරීක්ෂා කරන්න, සත්‍ය නම්, වැරදියට ආපසු යන්න.
  3. සිතියමට එක් එක් මූලද්‍රව්‍යයේ සංඛ්‍යාත ගබඩා කර ගණන් කරන්න.
  4. දෙවන අරාව හරහා ගමන් කිරීම,
    1. සිතියම arr2 මූලද්‍රව්‍ය අඩංගු නොවේ.
    2. එම විශේෂිත මූලද්‍රව්‍යයේ සංඛ්‍යාතය සත්‍ය නම් 0 ට සමාන දැයි පරීක්ෂා කර වැරදියට ආපසු යන්න.
    3. වත්මන් මූලද්‍රව්‍යයේ සංඛ්‍යාතය 1 කින් අඩු කරන්න, එය වත්මන් මූලද්‍රව්‍යයේ සංඛ්‍යාතයේ එම ස්ථානයට ගබඩා කරන්න.
  5. සියලු අගයන් ගමන් කරන තෙක් 4 වන පියවර නැවත කරන්න.
  6. නැවත සත්‍ය වේ.

පැහැදිලි කිරීම

ලබා දී ඇති අරා දෙක සමාන ද නැද්ද යන්න සොයා බැලීමට අපට ගැටළුවක් ඇත. මෙය විසඳීම සඳහා අපි භාවිතා කරන්නෙමු හැෂිං, එය අපගේ කාලය ඉතිරි කර ගැනීමට උපකාරී වන අතර කාලය සංකීර්ණතාව අඩු කරයි.

මෙයද බලන්න
වර්ග කිරීම ඒකාබද්ධ කරන්න

අපි කරන්න යන පළමු දෙය නම් අරා දෙකේම දිග සොයා ගැනීමයි. මන්දයත්, කොන්දේසිය සඳහා අරා සමාන නම්, එක් කොන්දේසියක් සපුරාලිය යුතු අතර, අරා දෙකේම දිග සමාන විය යුතුය, එබැවින් අරා දෙකේම දිග සොයාගත් විට, අපට සමානද නැද්ද යන්න පරීක්ෂා කර බැලිය යුතුය, එය සමාන යැයි සොයාගත නොහැකි නම් අපි අසත්‍යය නැවත ලබා දෙන අතර තවදුරටත් ඉදිරියට යාමට අවශ්‍ය නොවේ. එය සමාන බව සොයාගතහොත්, අපි තව දුරටත් ඉදිරියට යමු.

අපි අරාව 1 [] හි එක් එක් මූලද්‍රව්‍යයේ සංඛ්‍යාත ගණනය කර සිතියමට ගබඩා කරමු. අපි තනි මූලද්‍රව්‍යයක් දෙවරක් හෝ තුන් වරක් සොයා ගනිමු යැයි සිතමු, අපි යාවත්කාලීන කර එහි සංඛ්‍යාතය 1 කින් වැඩි කර එම මූලද්‍රව්‍යය සමඟ එම සංඛ්‍යාතයටම ගබඩා කරමු.

උදාහරණයක්

අපි උදාහරණයක් සලකා බලමු:

arr1 [] = {1, 4, 2, 5, 2};

arr2 [] = {2, 1, 5, 4, 2};

අරාව 1 [] හරහා ගමන් කර ඒවායේ සංඛ්‍යාත සමඟ ඇති සියලුම අංග සිතියමට ඇතුළත් කිරීමෙන් පසු අපට සිතියම පහත පරිදි වේ.

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

අපගේ සිතියමේ අගයන් ඇති බැවින්, අපි දෙවන අරාව හරහා ගමන් කර සිතියමක අරාව 2 මූලද්‍රව්‍ය තිබේදැයි පරීක්ෂා කළ යුතුය, එහි අරාව 2 [] මූලද්‍රව්‍ය අඩංගු නොවේ නම් අපි අසත්‍යය වෙත ආපසු යමු. අපි පරීක්ෂා කර බලමු, වත්මන් මූලද්‍රව්‍යයේ සංඛ්‍යාතය 0 ට සමාන නම්, එය සත්‍ය බව සොයාගත හොත් අපි අසත්‍යය වෙත ආපසු යමු. ඉන්පසු අපි වත්මන් මූලද්‍රව්‍ය සංඛ්‍යාතයේ අගය ගෙන එය 1 කින් අඩු කර නැවත අගය සිතියමට දමමු. එකම අංකය එක වරකට වඩා තිබේ නම් මෙය ඊළඟ වතාවට උපකාරී වේ. මෙම කොන්දේසිය එම අවස්ථාවේ දී ඇතුළත් වේ. අපි ලූපයෙන් පිටතට පැමිණි පසු, එයින් අදහස් වන්නේ අපට අරාවෙහි සියලු සංඛ්‍යා සමාන වන අතර අරා සමාන වන බවයි. එවිට අපි නැවත සැබෑ වෙමු.

මෙයද බලන්න
K විශේෂිත අංක සහිත කුඩාම සුබාරේ

අරා දෙකක් සමානද නැද්ද යන්න පරීක්ෂා කිරීමට C ++ කේතය  

#include <unordered_map>
#include<iostream>

using namespace std;

bool areTwoArrayEqual(int arr1[], int arr2[], int l1, int l2)
{
    if (l1 !=l2)
        return false;

    unordered_map<int, int> myMap;
    for (int i = 0; i < l1; i++)
    {
        myMap[arr1[i]]++;
    }
    for (int i = 0; i < l1; i++)
    {
        if (myMap.find(arr2[i]) == myMap.end())
            return false;

        if (myMap[arr2[i]] == 0)
            return false;

        myMap[arr2[i]]--;
    }

    return true;
}
int main()
{
    int arr1[] = { 1, 4, 2, 5, 2 };
    int arr2[] = { 2, 1, 5, 4, 2 };

    int l1 = sizeof(arr1) / sizeof(int);
    int l2 = sizeof(arr2) / sizeof(int);

    if (areTwoArrayEqual(arr1, arr2, l1, l2))
        cout << "Yes, Arrays are equal !!";
    else
        cout << "No, Arrays are not equal !!";
    return 0;
}
Yes, Arrays are equal !!

ජාවා කේතය අරා දෙකක් සමානද නැද්ද යන්න පරීක්ෂා කරන්න  

import java.util.*;

class twoArrayEqual
{
    public static boolean areTwoArrayEqual(int arr1[], int arr2[])
    {
        int l1 = arr1.length;
        int l2 = arr2.length;

        if (l1 != l2)
            return false;

        Map<Integer, Integer> myMap = new HashMap<Integer, Integer>();
        int count = 0;
        for (int i = 0; i < l1; i++)
        {
            if (myMap.get(arr1[i]) == null)
                myMap.put(arr1[i], 1);
            else
            {
                count = myMap.get(arr1[i]);
                count++;
                myMap.put(arr1[i], count);
            }
        }
        for (int i = 0; i < l1; i++)
        {
            if (!myMap.containsKey(arr2[i]))
                return false;

            if (myMap.get(arr2[i]) == 0)
                return false;

            count = myMap.get(arr2[i]);
            --count;
            myMap.put(arr2[i], count);
        }

        return true;
    }
    public static void main(String[] args)
    {
        int arr1[] = { 1, 4, 2, 5, 2 };
        int arr2[] = { 2, 1, 5, 4, 2 };

        if (areTwoArrayEqual(arr1, arr2))
            System.out.println("Yes, Arrays are equal !!");
        else
            System.out.println("No, Arrays are not equal !!");
    }
}
Yes, Arrays are equal !!

සංකීර්ණ විශ්ලේෂණය  

කාල සංකීර්ණත්වය

සාමාන්ය (n) එහිදී “N” යනු අරාවෙහි ඇති මූලද්‍රව්‍ය ගණන වේ. හැෂ්මැප් භාවිතා කිරීමෙන් අපට රේඛීය කාල සංකීර්ණත්වය ළඟා කර ගත හැකි විය. එසේ නොවුවහොත් ඊට වඩා වැඩි කාලයක් ගතවනු ඇත.

මෙයද බලන්න
අරාවෙහි ඇති මූලද්‍රව්‍යයක පළමු හා අවසාන දර්ශක අතර උපරිම වෙනස

අභ්‍යවකාශ සංකීර්ණතාව

සාමාන්ය (n) එහිදී “N” යනු අරාවෙහි ඇති මූලද්‍රව්‍ය ගණන වේ. සියලුම අංග එකිනෙකට වෙනස් නම්, අපගේ සිතියමට ආදානයේ එක් එක් අංක සඳහා යතුරු අගයක් ඇත. මේ අනුව අවකාශයේ සංකීර්ණතාව ද රේඛීය වේ.