ಶ್ರೇಣಿಯಲ್ಲಿ ಸಮಾನ ಅಂಶಗಳೊಂದಿಗೆ ಸೂಚ್ಯಂಕ ಜೋಡಿಗಳ ಎಣಿಕೆ  


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಮೆಜಾನ್ Atlassian ಸಿಟಾಡೆಲ್ ಫೇಸ್ಬುಕ್ ಪ್ರತ್ಯಕ್ಷ ಸ್ನ್ಯಾಪ್ಡಿಯಲ್ ಸ್ಕ್ವೇರ್ ಯಾಂಡೆಕ್ಸ್
ಅರೇ ಹ್ಯಾಶ್ ಹುಡುಕಲಾಗುತ್ತಿದೆ ವಿಂಗಡಿಸಲಾಗುತ್ತಿದೆ

ನಾವು ಒಂದು ನೀಡಿದ್ದೇವೆ ಎಂದು ಭಾವಿಸೋಣ ಪೂರ್ಣಾಂಕ ಸರಣಿ. “ಒಂದು ಶ್ರೇಣಿಯಲ್ಲಿ ಸಮಾನ ಅಂಶಗಳೊಂದಿಗೆ ಸೂಚ್ಯಂಕ ಜೋಡಿಗಳ ಎಣಿಕೆ” ಸಮಸ್ಯೆ ಯಾವುದೇ ಜೋಡಿ ಸೂಚ್ಯಂಕಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಕೇಳುತ್ತದೆ (i, ಜೆ) ಅಂತಹ ರೀತಿಯಲ್ಲಿ arr [i] = arr [j] ಮತ್ತು i ಗೆ ಸಮನಾಗಿಲ್ಲ j.

ಉದಾಹರಣೆ  

arr[] = {2,3,1,2,3,1,4}
3

ವಿವರಣೆ

ಸೂಚ್ಯಂಕಗಳ ಜೋಡಿಗಳು: (0, 3), (1, 4), (2, 5)

ಶ್ರೇಣಿಯಲ್ಲಿ ಸಮಾನ ಅಂಶಗಳೊಂದಿಗೆ ಸೂಚ್ಯಂಕ ಜೋಡಿಗಳ ಎಣಿಕೆ

arr[] = {3, 3, 1, 4}
1

ವಿವರಣೆ

ಸೂಚ್ಯಂಕಗಳ ಜೋಡಿಗಳು: (0, 1)

ಕ್ರಮಾವಳಿ  

  1. ಎ ಘೋಷಿಸಿ ನಕ್ಷೆ.
  2. ಸಂಚರಿಸಿ ಸರಣಿ ಮತ್ತು ಪ್ರತಿ ಅಂಶದ ಆವರ್ತನವನ್ನು ನಕ್ಷೆಯಲ್ಲಿ ಎಣಿಸಿ ಮತ್ತು ಸಂಗ್ರಹಿಸಿ.
  3. Output ಟ್ಪುಟ್ ಅನ್ನು 0 ಗೆ ಹೊಂದಿಸಿ.
  4. ನಕ್ಷೆಯಲ್ಲಿ ಸಂಚರಿಸಿ ಮತ್ತು ನಕ್ಷೆಯಿಂದ ಪ್ರತಿ ಅಂಶದ ಆವರ್ತನವನ್ನು ಪಡೆಯಿರಿ.
  5. Output ಟ್ಪುಟ್ ಮಾಡಿ + = (VAL * (VAL - 1)) / 2, VAL ಎಂಬುದು ಪ್ರತಿ ಅಂಶದ ಆವರ್ತನವಾಗಿದೆ.
  6. ರಿಟರ್ನ್ .ಟ್‌ಪುಟ್.

ವಿವರಣೆ

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

ನಾವು ನಕ್ಷೆಯನ್ನು ಘೋಷಿಸುತ್ತೇವೆ, ಪ್ರತಿ ಅಂಶವನ್ನು ಎತ್ತಿಕೊಳ್ಳುತ್ತೇವೆ, ಪ್ರತಿ ಅಂಶದ ಆವರ್ತನವನ್ನು ನಕ್ಷೆಯಲ್ಲಿ ಎಣಿಸುತ್ತೇವೆ ಮತ್ತು ಸಂಗ್ರಹಿಸುತ್ತೇವೆ, ಅದು ಈಗಾಗಲೇ ನಕ್ಷೆಯಲ್ಲಿದ್ದರೆ, ಅದಕ್ಕಾಗಿ ಒಂದು ಸ್ಥಳವನ್ನು ಮಾಡಿ, ಅದು ಇದ್ದರೆ ಅದರ ಆವರ್ತನವನ್ನು ಈಗಾಗಲೇ 1 ರಷ್ಟು ಹೆಚ್ಚಿಸಿ.

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

ಸಂಯೋಜನೆಯ ಸೂತ್ರವನ್ನು ಬಳಸಲು, ನಾವು ಪ್ರತಿ ಸಂಖ್ಯೆಯ ಆವರ್ತನವನ್ನು ಎಣಿಸಬೇಕಾಗಿದೆ. ಸಮಾನ ಅಂಶಗಳ ನಿರ್ದಿಷ್ಟ ಸ್ಥಿತಿಯನ್ನು ಪೂರೈಸುವ ಹಲವಾರು ಜೋಡಿಗಳನ್ನು ನಾವು ಆಯ್ಕೆ ಮಾಡಲಿದ್ದೇವೆ ಆದರೆ ಅವುಗಳ ಸೂಚ್ಯಂಕಗಳಲ್ಲ. ಒಂದು ಶ್ರೇಣಿಯಲ್ಲಿರುವ ಯಾವುದೇ ಸಂಖ್ಯೆಯು kth ಸೂಚ್ಯಂಕದವರೆಗಿನ ಯಾವುದೇ ಸೂಚ್ಯಂಕದಲ್ಲಿ k ಬಾರಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಎಂದು ನಾವು can ಹಿಸಬಹುದು. ನಂತರ ಯಾವುದೇ ಎರಡು ಸೂಚ್ಯಂಕಗಳನ್ನು ಆರಿಸಿ ai ಮತ್ತುy ಇದನ್ನು 1 ಜೋಡಿ ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ. ಅಂತೆಯೇ, ಎy ಮತ್ತುx ಜೋಡಿಯಾಗಿರಬಹುದು. ಆದ್ದರಿಂದ, nC2 ಜೋಡಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯುವ ಸೂತ್ರವೆಂದರೆ ಆರ್ [i] = ಆರ್ [ಜೆ] ಸಹ x ಗೆ ಸಮಾನವಾಗಿರುತ್ತದೆ.

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

ಶ್ರೇಣಿಯಲ್ಲಿ ಸಮಾನ ಅಂಶಗಳೊಂದಿಗೆ ಸೂಚ್ಯಂಕ ಜೋಡಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯಲು ಸಿ ++ ಕೋಡ್  

#include<iostream>
#include<unordered_map>

using namespace std;

int getNoOfPairs(int arr[], int n)
{
    unordered_map<int, int> MAP;

    for (int i = 0; i < n; i++)
        MAP[arr[i]]++;

    int output = 0;
    for (auto it=MAP.begin(); it!=MAP.end(); it++)
    {
        int VAL = it->second;
        output += (VAL * (VAL - 1))/2;
    }
    return output;
}
int main()
{
    int arr[] = {2,3,1,2,3,1,4};
    int n = sizeof(arr)/sizeof(arr[0]);
    cout << getNoOfPairs(arr, n) << endl;
    return 0;
}
3

ಒಂದು ಶ್ರೇಣಿಯಲ್ಲಿ ಸಮಾನ ಅಂಶಗಳೊಂದಿಗೆ ಸೂಚ್ಯಂಕ ಜೋಡಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯಲು ಜಾವಾ ಕೋಡ್  

import java.util.HashMap;
import java.util.Map;

class countIndexPair
{
    public static int getNoOfPairs(int arr[], int n)
    {
        HashMap<Integer,Integer> MAP = new HashMap<>();

        for(int i = 0; i < n; i++)
        {
            if(MAP.containsKey(arr[i]))
                MAP.put(arr[i],MAP.get(arr[i]) + 1);
            else
                MAP.put(arr[i], 1);
        }
        int output=0;
        for(Map.Entry<Integer,Integer> entry : MAP.entrySet())
        {
            int VAL = entry.getValue();
            output += (VAL * (VAL - 1)) / 2;
        }
        return output;
    }
    public static void main(String[] args)
    {
        int arr[]= {2,3,1,2,3,1,4};
        System.out.println(getNoOfPairs(arr,arr.length));
    }
}
3

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

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

ಓ (ಎನ್) ಅಲ್ಲಿ “ಎನ್” ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆ.

ಸಹ ನೋಡಿ
ಪುನರಾವರ್ತಿತ ಪೂರ್ವ ಆದೇಶದ ಅಡ್ಡಹಾಯುವಿಕೆ

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

ಓ (ಎನ್) ಅಲ್ಲಿ “ಎನ್” ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆ.