ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਦੋ ਐਰੇ ਬਰਾਬਰ ਹਨ ਜਾਂ ਨਹੀਂ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਦਰਮਿਆਨੇ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ Accenture ਗੋਲਡਮੈਨ ਸਾਕਸ ਮੈਕ o9 ਹੱਲ ਟੈਕਸੀ 4 ਸੂਅਰ Twilio
ਅਰੇ ਹੈਸ਼ ਲੜੀਬੱਧ

“ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਦੋ ਐਰੇ ਬਰਾਬਰ ਹਨ ਜਾਂ ਨਹੀਂ” ਦੱਸਦਾ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਦੋ ਦਿੱਤੀਆਂ ਗਈਆਂ ਹਨ ਐਰੇ. ਸਮੱਸਿਆ ਦਾ ਬਿਆਨ ਕਹਿੰਦਾ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨਾ ਪਏਗਾ ਕਿ ਦਿੱਤੀ ਗਈ ਐਰੇ ਬਰਾਬਰ ਹਨ ਜਾਂ ਨਹੀਂ.

ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਦੋ ਐਰੇ ਬਰਾਬਰ ਹਨ ਜਾਂ ਨਹੀਂ

ਉਦਾਹਰਨ

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. ਚੈੱਕ ਕਰੋ ਕਿ ਜੇ ਫੋਲਡਰ ਨੂੰ ਐਰ 2 ਤੱਤ ਨਹੀਂ ਰੱਖਦਾ, ਗਲਤ ਵਾਪਸ ਆਉ.
    2. ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਉਸ ਵਿਸ਼ੇਸ਼ ਤੱਤ ਦੀ ਬਾਰੰਬਾਰਤਾ 0 ਦੇ ਬਰਾਬਰ ਹੈ ਜੇ ਸਹੀ ਹੈ ਤਾਂ ਗਲਤ ਵਾਪਸ ਆਓ.
    3. ਮੌਜੂਦਾ ਤੱਤ ਦੀ ਬਾਰੰਬਾਰਤਾ ਨੂੰ 1 ਨਾਲ ਘਟਾਓ, ਇਸ ਨੂੰ ਮੌਜੂਦਾ ਤੱਤ ਦੀ ਬਾਰੰਬਾਰਤਾ ਦੀ ਜਗ੍ਹਾ ਤੇ ਸਟੋਰ ਕਰੋ.
  5. ਚੌਥੇ ਪੜਾਅ ਨੂੰ ਦੁਹਰਾਓ ਜਦੋਂ ਤਕ ਸਾਰੇ ਮੁੱਲ ਟ੍ਰਾਂਸ ਨਹੀਂ ਹੋ ਜਾਂਦੇ.
  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 ਤੱਕ ਘਟਾਉਂਦੇ ਹਾਂ ਅਤੇ ਦੁਬਾਰਾ ਮੁੱਲ ਨੂੰ ਨਕਸ਼ੇ ਵਿੱਚ ਪਾਉਂਦੇ ਹਾਂ. ਤਾਂ, ਇਹ ਅਗਲੀ ਵਾਰ ਮਦਦ ਕਰੇਗੀ ਜੇ ਉਹੀ ਸੰਖਿਆ ਇਕ ਤੋਂ ਵੱਧ ਸਮੇਂ ਲਈ ਮੌਜੂਦ ਰਹੇ. ਇਹ ਸ਼ਰਤ ਉਸ ਕੇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੀ ਗਈ ਹੈ. ਇਕ ਵਾਰ ਜਦੋਂ ਅਸੀਂ ਲੂਪ ਵਿਚੋਂ ਬਾਹਰ ਆ ਜਾਵਾਂਗੇ, ਇਸਦਾ ਅਰਥ ਹੈ ਕਿ ਸਾਡੇ ਕੋਲ ਐਰੇ ਵਿਚ ਸਾਰੇ ਨੰਬਰ ਇਕੋ ਜਿਹੇ ਹਨ ਅਤੇ ਐਰੇ ਬਰਾਬਰ ਬਣਾਉਂਦੇ ਹਾਂ. ਤਦ ਅਸੀਂ ਸੱਚੇ ਰਾਹ ਵਾਪਸ ਆਵਾਂਗੇ.

ਸੀ ++ ਕੋਡ ਨੂੰ ਚੈੱਕ ਕਰਨ ਲਈ ਕਿ ਕੀ ਦੋ ਐਰੇ ਬਰਾਬਰ ਹਨ ਜਾਂ ਨਹੀਂ

#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) ਜਿੱਥੇ ਕਿ “ਐਨ” ਐਰੇ ਵਿਚਲੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਹੈ. ਜੇ ਸਾਰੇ ਤੱਤ ਵੱਖਰੇ ਹੋਣਗੇ, ਤਾਂ ਸਾਡੇ ਨਕਸ਼ੇ ਦੇ ਇੰਪੁੱਟ ਵਿਚ ਹਰੇਕ ਨੰਬਰ ਲਈ ਕੁੰਜੀ-ਮੁੱਲ ਹੋਵੇਗਾ. ਇਸ ਤਰ੍ਹਾਂ ਪੁਲਾੜ ਦੀ ਗੁੰਝਲਤਾ ਵੀ ਲੀਨੀਅਰ ਹੈ.