ಎರಡು ಸರಣಿಗಳು ಸಮಾನವಾಗಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸಿ


ತೊಂದರೆ ಮಟ್ಟ ಮಧ್ಯಮ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಸೆಂಚರ್ ಗೋಲ್ಡ್ಮನ್ ಸ್ಯಾಚ್ಸ್ MAQ o9 ಪರಿಹಾರಗಳು ಟ್ಯಾಕ್ಸಿ 4 ಸ್ಯೂರ್ ಟ್ವಿಲಿಯೊ
ಅರೇ ಹ್ಯಾಶ್ ವಿಂಗಡಿಸಲಾಗುತ್ತಿದೆ

“ಎರಡು ಸರಣಿಗಳು ಸಮಾನವಾಗಿದೆಯೆ ಅಥವಾ ಇಲ್ಲವೇ ಎಂದು ಪರಿಶೀಲಿಸಿ” ಎಂಬ ಸಮಸ್ಯೆ ನಿಮಗೆ ಎರಡು ನೀಡಲಾಗಿದೆ ಎಂದು ಹೇಳುತ್ತದೆ ಸರಣಿಗಳು. ಕೊಟ್ಟಿರುವ ಸರಣಿಗಳು ಸಮಾನವಾಗಿದೆಯೆ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ನೀವು ನಿರ್ಧರಿಸಬೇಕು ಎಂದು ಸಮಸ್ಯೆ ಹೇಳಿಕೆಯು ಹೇಳುತ್ತದೆ.

ಎರಡು ಸರಣಿಗಳು ಸಮಾನವಾಗಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸಿ

ಉದಾಹರಣೆ

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 ಕ್ಕೆ ಇಳಿಸಿ ಮತ್ತೆ ಮೌಲ್ಯವನ್ನು ನಕ್ಷೆಯಲ್ಲಿ ಇಡುತ್ತೇವೆ. ಆದ್ದರಿಂದ, ಒಂದೇ ಸಂಖ್ಯೆ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಬಾರಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ ಇದು ಮುಂದಿನ ಬಾರಿ ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ ಈ ಸ್ಥಿತಿಯನ್ನು ಸೇರಿಸಲಾಗಿದೆ. ಒಮ್ಮೆ ನಾವು ಲೂಪ್ನಿಂದ ಹೊರಬರುತ್ತೇವೆ, ಇದರರ್ಥ ನಾವು ಎಲ್ಲಾ ಸಂಖ್ಯೆಗಳನ್ನು ರಚನೆಯಲ್ಲಿ ಹೋಲುತ್ತೇವೆ ಮತ್ತು ಸರಣಿಗಳನ್ನು ಸಮಾನಗೊಳಿಸುತ್ತೇವೆ. ನಂತರ ನಾವು ನಿಜವಾಗುತ್ತೇವೆ.

ಎರಡು ಸರಣಿಗಳು ಸಮಾನವಾಗಿದೆಯೆ ಅಥವಾ ಇಲ್ಲವೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ಸಿ ++ ಕೋಡ್

#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 !!

ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

ಸಮಯ ಸಂಕೀರ್ಣತೆ

ಓ (ಎನ್) ಅಲ್ಲಿ “ಎನ್” ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆ. ಹ್ಯಾಶ್‌ಮ್ಯಾಪ್ ಅನ್ನು ಬಳಸುವುದರಿಂದ ರೇಖೀಯ ಸಮಯದ ಸಂಕೀರ್ಣತೆಯನ್ನು ಸಾಧಿಸಲು ನಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಟ್ಟಿತು, ಇಲ್ಲದಿದ್ದರೆ ಅದು ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ

ಓ (ಎನ್) ಅಲ್ಲಿ “ಎನ್” ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆ. ಎಲ್ಲಾ ಅಂಶಗಳು ವಿಭಿನ್ನವಾಗಿದ್ದರೆ, ನಮ್ಮ ನಕ್ಷೆಯು ಇನ್‌ಪುಟ್‌ನಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು ಸಂಖ್ಯೆಗಳಿಗೆ ಕೀ-ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಹೀಗಾಗಿ ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆಯೂ ರೇಖೀಯವಾಗಿರುತ್ತದೆ.