ಜೋಡಿಗಳ ಜೋಡಿಯನ್ನು ನೀಡಲಾಗಿದೆ ಅದರಲ್ಲಿ ಎಲ್ಲಾ ಸಮ್ಮಿತೀಯ ಜೋಡಿಗಳನ್ನು ಹುಡುಕಿ  


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಮೆಜಾನ್ Capgemini ಮತ್ತು ಸಿಸ್ಕೋ ಫ್ರೀಚಾರ್ಜ್ ಮೂನ್‌ಫ್ರಾಗ್ ಲ್ಯಾಬ್‌ಗಳು ಒಪೆರಾ ಕ್ಸೋಮ್
ಅರೇ ಹ್ಯಾಶ್

ಎಲ್ಲಾ ಸಮ್ಮಿತೀಯ ಜೋಡಿಗಳನ್ನು ಹುಡುಕಿ - ನಿಮಗೆ ಕೆಲವು ಜೋಡಿಗಳನ್ನು ನೀಡಲಾಗಿದೆ ಸರಣಿ. ಅದರಲ್ಲಿರುವ ಸಮ್ಮಿತೀಯ ಜೋಡಿಗಳನ್ನು ನೀವು ಕಂಡುಹಿಡಿಯಬೇಕು. ಜೋಡಿಗಳಲ್ಲಿ (ಎ, ಬಿ) ಮತ್ತು (ಸಿ, ಡಿ) ಜೋಡಿಗಳಲ್ಲಿ 'ಬಿ' 'ಸಿ' ಗೆ ಸಮನಾಗಿರುತ್ತದೆ ಮತ್ತು 'ಎ' 'ಡಿ' ಗೆ ಸಮಾನವಾಗಿರುತ್ತದೆ, ಅಂದರೆ (1) ಸಮ್ಮಿತೀಯ ಜೋಡಿ ಸಮ್ಮಿತೀಯ ಎಂದು ಹೇಳಲಾಗುತ್ತದೆ. , 2) (2, 1) ನ ಸಮ್ಮಿತೀಯ ಜೋಡಿ.

ಉದಾಹರಣೆ  

ಜೋಡಿಗಳ ಜೋಡಿಯನ್ನು ನೀಡಲಾಗಿದೆ ಅದರಲ್ಲಿ ಎಲ್ಲಾ ಸಮ್ಮಿತೀಯ ಜೋಡಿಗಳನ್ನು ಹುಡುಕಿಪಿನ್

{{11, 20},{30,40},{4,5},{5,4},{40,30}}
(4, 5) (30, 40)

ಎಲ್ಲಾ ಸಮ್ಮಿತೀಯ ಜೋಡಿಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಅಲ್ಗಾರಿದಮ್  

  1. ಎ ಘೋಷಿಸಿ ಹ್ಯಾಶ್‌ಮ್ಯಾಪ್.
  2. ಆದರೆ i <n (ರಚನೆಯ ಉದ್ದ)
    1. ಹೊಂದಿಸಿ ಮೊದಲ ಮೌಲ್ಯ ರಚಿಸಲು [i] [0] ಮತ್ತು ಎರಡನೇ ಮೌಲ್ಯ to arr [i] [1].
    2. ಸೆಕೆಂಡ್‌ವಾಲ್ಯೂನ ಮೌಲ್ಯವು ಶೂನ್ಯವಾಗಿಲ್ಲವೇ ಮತ್ತು ಸೆಕೆಂಡ್‌ವಾಲ್ಯೂನ ಮೌಲ್ಯವು ಫಸ್ಟ್‌ವಾಲ್ಯೂಗೆ ಸಮನಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ
    3. ನಿಜವಾಗಿದ್ದರೆ, ಎರಡನೇ ಮೌಲ್ಯ ಮತ್ತು ಪ್ರಥಮ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸಿ.
    4. ಬೇರೆ ಫಸ್ಟ್‌ವಾಲ್ಯೂ ಮತ್ತು ಸೆಕೆಂಡ್‌ವಾಲ್ಯೂ ಅನ್ನು ಹ್ಯಾಶ್‌ಮ್ಯಾಪ್‌ನಲ್ಲಿ ಇರಿಸಿ.
  3. ಲೂಪ್ ಇರುವವರೆಗೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು a ನಿಂದ d ಗೆ ಪುನರಾವರ್ತಿಸಿ.

ವಿವರಣೆ

ನಾವು ಒಂದು ಶ್ರೇಣಿಯ ಜೋಡಿಗಳನ್ನು ನೀಡಿದ್ದೇವೆ, ಆ ರಚನೆಯೊಳಗೆ ಕೆಲವು ಸಮ್ಮಿತೀಯ ಜೋಡಿಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ. ಒಂದು ಶ್ರೇಣಿಯಲ್ಲಿರುವ ಎಲ್ಲಾ ಸಮ್ಮಿತೀಯ ಜೋಡಿಗಳನ್ನು ನಾವು ಕಂಡುಹಿಡಿಯಬೇಕು ಎಂದು ಸಮಸ್ಯೆ ಹೇಳಿಕೆಯು ಹೇಳುತ್ತದೆ. ನಾವು ಕೇವಲ ಎರಡು ಕುಣಿಕೆಗಳನ್ನು ಬಳಸಬಹುದು ಮತ್ತು ಎರಡೂ ಸರಣಿಗಳನ್ನು ಒಂದೊಂದಾಗಿ ಚಲಿಸಬಹುದು. ಆದರೆ ಇದು ನಮಗೆ ಹೆಚ್ಚಿನ ಸಮಯದ ಸಂಕೀರ್ಣತೆಯನ್ನು ವೆಚ್ಚ ಮಾಡುತ್ತದೆ ಮತ್ತು ನಮಗೆ ದಕ್ಷ ಕೋಡ್ ಇರಲು ಸಾಧ್ಯವಿಲ್ಲ. ನಿರ್ದಿಷ್ಟ ಕ್ರಮದಲ್ಲಿ ಮೊದಲು ಅವುಗಳನ್ನು ವಿಂಗಡಿಸಲು ನಾವು ಉತ್ತಮ ವಿಧಾನವನ್ನು ಬಳಸಲು ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ ಆದರೆ ಅದು ನಮ್ಮ ದಕ್ಷತೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಆದ್ದರಿಂದ ಪರಿಣಾಮಕಾರಿ ಪ್ರೋಗ್ರಾಂ ಪಡೆಯಲು ನಾವು ಹ್ಯಾಶಿಂಗ್ ಅನ್ನು ಬಳಸಬೇಕು.

ಸಹ ನೋಡಿ
ಉದ್ದದ ಫೈಬೊನಾಕಿ ನಂತರದ ಉದ್ದ

ಹ್ಯಾಶ್‌ಮ್ಯಾಪ್ ಬಳಸುವ ಮೂಲಕ, ನಾವು ಮೊದಲು ಜೋಡಿಯ ಮೊದಲ ಅಂಶವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತೇವೆ ಮೊದಲ ಮೌಲ್ಯ ಮತ್ತು ಜೋಡಿಯ ಎರಡನೇ ಅಂಶ ಎರಡನೇ ಮೌಲ್ಯ, ನಾವು ಜೋಡಿಯ ಎರಡೂ ಅಂಶಗಳನ್ನು ಕೀ ಮತ್ತು ಮೌಲ್ಯವಾಗಿ ಬಳಸಬಹುದು. ಒಂದು ಜೋಡಿಯ ಕೀಲಿಯನ್ನು ಮತ್ತೊಂದು ಜೋಡಿಯ ಮೌಲ್ಯಕ್ಕೆ ಮತ್ತು ಅದೇ ಜೋಡಿಯ ಮೌಲ್ಯವನ್ನು ಮತ್ತೊಂದು ಜೋಡಿಯ ಕೀಲಿಯೊಂದಿಗೆ ಹೋಲಿಸುವ ಮೂಲಕ ನಾವು ಅದನ್ನು ನಕ್ಷೆಯಲ್ಲಿ ಹುಡುಕುತ್ತೇವೆ.

ನಾವು ಹ್ಯಾಶ್‌ಮ್ಯಾಪ್ ಅನ್ನು ಬಳಸಲಿದ್ದೇವೆ ಜೋಡಿಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನೀಡಲು ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸೋಣ, ಅದರಲ್ಲಿ ಎಲ್ಲಾ ಸಮ್ಮಿತೀಯ ಜೋಡಿಗಳನ್ನು ಹುಡುಕಿ

ಉದಾಹರಣೆ

arr={{1, 2},{30,40},{6,9},{2,1},{9,6}}

ನಾವು ರಚನೆಯ ಜೋಡಿ ಮೌಲ್ಯವನ್ನು ಫಸ್ಟ್‌ವಾಲ್ಯು ಮತ್ತು ಸೆಕೆಂಡ್‌ವಾಲ್ಯೂ ಆಗಿ ಸಂಗ್ರಹಿಸುತ್ತೇವೆ ಮತ್ತು ನಂತರ ನಾವು ಅದನ್ನು ಪರಿಶೀಲಿಸುತ್ತೇವೆ.

i = 0,

firstValue = arr [i] [0] // ಜೋಡಿ 1 ನೇ ಅಂಶ

secondValue = arr [i] [1] // ಜೋಡಿ 2 ನೇ ಅಂಶ

firstValue = 1, secondValue = 2

1 ರಲ್ಲಿ ನಕ್ಷೆಯಲ್ಲಿ ಮೌಲ್ಯವಿದೆಯೇ ಮತ್ತು ಷರತ್ತು ತಪ್ಪಾಗಿದೆಯೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ ಆದ್ದರಿಂದ ಅದು ಎರಡೂ ಮೌಲ್ಯವನ್ನು ನಕ್ಷೆಯಲ್ಲಿ ಇರಿಸುತ್ತದೆ.

ನಕ್ಷೆ = [{1: 2}]

i = 1,

firstValue = arr [i] [0] // ಜೋಡಿ 1 ನೇ ಅಂಶ

secondValue = arr [i] [1] // ಜೋಡಿ 2 ನೇ ಅಂಶ

firstValue = 30, secondValue = 40

30 ರಲ್ಲಿ ನಕ್ಷೆಯಲ್ಲಿ ಮೌಲ್ಯವಿದೆಯೇ ಮತ್ತು ಷರತ್ತು ತಪ್ಪಾಗಿದೆಯೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ ಆದ್ದರಿಂದ ಅದು ಎರಡೂ ಮೌಲ್ಯವನ್ನು ನಕ್ಷೆಯಲ್ಲಿ ಇರಿಸುತ್ತದೆ.

ನಕ್ಷೆ = [{1: 2}, {30:40}]

i = 2,

firstValue = arr [i] [0] // ಜೋಡಿ 1 ನೇ ಅಂಶ

secondValue = arr [i] [1] // ಜೋಡಿ 2 ನೇ ಅಂಶ

firstValue = 6, secondValue = 9

6 ರಲ್ಲಿ ನಕ್ಷೆಯಲ್ಲಿ ಮೌಲ್ಯವಿದೆಯೇ ಮತ್ತು ಷರತ್ತು ತಪ್ಪಾಗಿದೆಯೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ ಆದ್ದರಿಂದ ಅದು ಎರಡೂ ಮೌಲ್ಯವನ್ನು ನಕ್ಷೆಯಲ್ಲಿ ಇರಿಸುತ್ತದೆ.

Map=[{1:2},{30:40},{6:9}]

i = 3,

firstValue = arr [i] [0] // ಜೋಡಿ 1 ನೇ ಅಂಶ

secondValue = arr [i] [1] // ಜೋಡಿ 2 ನೇ ಅಂಶ

firstValue = 2, secondValue = 1

1 ರಲ್ಲಿ ನಕ್ಷೆಯಲ್ಲಿ ಮೌಲ್ಯವಿದೆಯೇ ಮತ್ತು ಅದು '2' ಎಂದು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ, ನಂತರ ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ, ಸೆಕೆಂಡ್‌ವಾಲ್ಯೂನ ಅಂಶವು ಫಸ್ಟ್‌ವಾಲ್ಯೂಗೆ ಸಮನಾಗಿದ್ದರೆ ಮತ್ತು ಈ ಸ್ಥಿತಿಯು ಸಹ ಪೂರೈಸುತ್ತದೆ.

ಸಹ ನೋಡಿ
ಮೊದಲು ಧನಾತ್ಮಕ ಕಾಣೆಯಾಗಿದೆ

ಆದ್ದರಿಂದ ನಾವು ಮುದ್ರಿಸುತ್ತೇವೆ (1, 2)

Map=[{1:2},{30:40},{6:9}]

i = 4,

firstValue = arr [i] [0] // ಜೋಡಿ 1 ನೇ ಅಂಶ

secondValue = arr [i] [1] // ಜೋಡಿ 2 ನೇ ಅಂಶ

firstValue = 9, secondValue = 6

ನಕ್ಷೆಯಲ್ಲಿ ಮೌಲ್ಯವು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಮತ್ತು ಅದು '6' ಎಂದು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಎಂದು ನಾವು 9 ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತೇವೆ, ನಂತರ ಸೆಕೆಂಡ್‌ವಾಲ್ಯೂನ ಅಂಶವು ಫಸ್ಟ್‌ವಾಲ್ಯೂಗೆ ಸಮನಾಗಿದೆಯೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ ಮತ್ತು ಈ ಸ್ಥಿತಿಯು ಸಹ ಪೂರೈಸುತ್ತದೆ.

ಆದ್ದರಿಂದ ನಾವು (1, 2), (6, 9) ಮುದ್ರಿಸುತ್ತೇವೆ

Map=[{1:2},{30:40},{6:9}]

ಕೋಡ್  

ಎಲ್ಲಾ ಸಮ್ಮಿತೀಯ ಜೋಡಿಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಸಿ ++ ಪ್ರೋಗ್ರಾಂ

#include<unordered_map>
#include<iostream>
using namespace std;
void getSymmetricPair(int arr[][2], int row)
{
    unordered_map<int, int> myMap;

    for (int i = 0; i < row; i++)
    {
        int firstValue = arr[i][0];
        int secondValue = arr[i][1];

        if (myMap.find(secondValue) != myMap.end() && myMap[secondValue] == firstValue)
        {
            cout << "(" << secondValue << ", " << firstValue << ")"<<" ";
        }
        else
        {
            myMap[firstValue] = secondValue;
        }
    }
}
int main()
{
    int arr[5][2]= {{11,20},{30,40},{4,5},{5,4},{40,30}};
    getSymmetricPair(arr, 5);
}
(4, 5) (30, 40)

ಎಲ್ಲಾ ಸಮ್ಮಿತೀಯ ಜೋಡಿಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಜಾವಾ ಪ್ರೋಗ್ರಾಂ

import java.util.HashMap;
class pairSymmetrics
{
    static void getSymmetricPair(int arr[][])
    {
        HashMap<Integer, Integer> hashmap = new HashMap<Integer, Integer>();

        for (int i = 0; i < arr.length; i++)
        {
            int firstValue = arr[i][0];
            int secondValue = arr[i][1];
            Integer val = hashmap.get(secondValue);

            if (val != null && val == firstValue)
            {
                System.out.print("(" + secondValue + ", " + firstValue + ")" + " ");
            }
            else
            {
                hashmap.put(firstValue, secondValue);
            }
        }
    }

    public static void main(String arg[])
    {
        int arr[][]= {{11,20},{30,40},{4,5},{5,4},{40,30}};
        getSymmetricPair(arr);

    }
}
(4, 5) (30, 40)

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

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

ಓ (ಎನ್) ಅಲ್ಲಿ “ಎನ್” ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆ. ನಾವು ಹ್ಯಾಶ್‌ಮ್ಯಾಪ್ ಅನ್ನು ಬಳಸಿದ್ದರಿಂದ ನಾವು ಒಳಸೇರಿಸುವಿಕೆ / ಅಳಿಸುವಿಕೆ / ಹುಡುಕಾಟವನ್ನು ಮಾಡಬಹುದು ಒ (1) ಸಮಯ.

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

ಓ (ಎನ್) ಅಲ್ಲಿ “ಎನ್” ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆ. ನಾವು ನಕ್ಷೆಯಲ್ಲಿ ಅಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸಿದ್ದರಿಂದ. ಸ್ಥಳದ ಸಂಕೀರ್ಣತೆಯು ರೇಖೀಯವಾಗಿದೆ.

ಉಲ್ಲೇಖಗಳು