ಕೊಟ್ಟಿರುವ ಮೊತ್ತದೊಂದಿಗೆ ಜೋಡಿಯನ್ನು ಎಣಿಸಿ


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

ಸಮಸ್ಯೆಯಲ್ಲಿ “ಕೊಟ್ಟಿರುವ ಮೊತ್ತದೊಂದಿಗೆ ಜೋಡಿ ಎಣಿಕೆ” ನಾವು ಒಂದು ಪೂರ್ಣಾಂಕವನ್ನು ನೀಡಿದ್ದೇವೆ ಸರಣಿ[] ಮತ್ತು ಇನ್ನೊಂದು ಸಂಖ್ಯೆಯು 'ಮೊತ್ತ' ಎಂದು ಹೇಳುತ್ತದೆ, ನಿರ್ದಿಷ್ಟ ಶ್ರೇಣಿಯಲ್ಲಿನ ಎರಡು ಅಂಶಗಳಲ್ಲಿ ಯಾವುದಾದರೂ ಮೊತ್ತವು "ಮೊತ್ತ" ಕ್ಕೆ ಸಮಾನವಾಗಿದೆಯೇ ಎಂದು ನೀವು ನಿರ್ಧರಿಸಬೇಕು.

ಉದಾಹರಣೆ

ಇನ್ಪುಟ್:

arr [] = {1,3,4,6,7} ಮತ್ತು ಮೊತ್ತ = 9.

ಔಟ್ಪುಟ್:

"ಕೊಟ್ಟಿರುವ ಅಂಶಗಳು ಕಂಡುಬರುತ್ತವೆ ಮೊತ್ತ ”ಸಮನಾಗಿರುವ '3' ಮತ್ತು '6' ಇರುವುದರಿಂದ '9' ಗೆ.

ಇನ್ಪುಟ್:

arr [] = {11,3,5,7,10} ಮತ್ತು ಮೊತ್ತ = 20.

ಔಟ್ಪುಟ್:

'8' ಗೆ ಸಮನಾದ ಯಾವುದೇ ಸಂಖ್ಯೆಯಿಲ್ಲದ ಕಾರಣ "ಕೊಟ್ಟಿರುವ ಮೊತ್ತದೊಂದಿಗೆ ಅಂಶಗಳು ಕಂಡುಬಂದಿಲ್ಲ".

ಕ್ರಮಾವಳಿ

  1. ಎ ಘೋಷಿಸಿ ಸೆಟ್.
  2. 0 ರಿಂದ 'ನಾನು' ರಚನೆಯ ಉದ್ದಕ್ಕಿಂತ ಕಡಿಮೆಯಿದ್ದರೆ.
    1. J ಅನ್ನು sum-arr [i] ಗೆ ಹೊಂದಿಸಿ.
    2. ಸೆಟ್ 'j' ಅನ್ನು ಹೊಂದಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ, ನಿಜವಾಗಿದ್ದರೆ j ಮತ್ತು arr [i] ಅನ್ನು ಮುದ್ರಿಸಿ, ಇದು ಜೋಡಿಯಾಗಿರುತ್ತದೆ.
    3. ಇಲ್ಲದಿದ್ದರೆ ಸೆಟ್ ಅನ್ನು ಅರ್ [i] ಅನ್ನು ಸೇರಿಸಿ.

ವಿವರಣೆ

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

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

ಅದನ್ನು ಕಂಡುಹಿಡಿಯಲು, ನಾವು ಹ್ಯಾಶಿಂಗ್ ವಿಧಾನವನ್ನು ಬಳಸುತ್ತೇವೆ.

ನಾವು ಒಂದು ಉದಾಹರಣೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ:

arr [] = {1, 4, 45, 6, 10, 8};

  • i = 0, ಮೈಸೆಟ್, ಮೊತ್ತ = 16;

j = sum-arr [i];

ಅದು j = 16-1 = 15 ಮತ್ತು ಖಂಡಿತವಾಗಿಯೂ 'j' ನಕ್ಷೆಯಲ್ಲಿ ಇರುವುದಿಲ್ಲ.

ಆದ್ದರಿಂದ ಇದು ಮೈಸೆಟ್‌ಗೆ '1' ಆಗಿರುವ ಅರ್ [i] ಅನ್ನು ಸೇರಿಸುತ್ತದೆ.

  • i = 1, ಮೈಸೆಟ್ = {1}, ಮೊತ್ತ = 16;

j = sum-arr [i];

ಅದು j = 16-4 = 12 ಮತ್ತು ಖಂಡಿತವಾಗಿಯೂ 'j' ನಕ್ಷೆಯಲ್ಲಿ ಇರುವುದಿಲ್ಲ.

ಆದ್ದರಿಂದ ಇದು ಮೈಸೆಟ್‌ಗೆ '4' ಆಗಿರುವ ಅರ್ [i] ಅನ್ನು ಸೇರಿಸುತ್ತದೆ.

  • i = 2, ಮೈಸೆಟ್ = {1, 4}, ಮೊತ್ತ = 16;

j = sum-arr [i];

ಅದು j = 16-45 = -29 ಮತ್ತು ಖಂಡಿತವಾಗಿಯೂ 'j' ನಕ್ಷೆಯಲ್ಲಿ ಇರುವುದಿಲ್ಲ.

ಆದ್ದರಿಂದ ಇದು ಮೈಸೆಟ್‌ಗೆ '45' ಆಗಿರುವ ಅರ್ [i] ಅನ್ನು ಸೇರಿಸುತ್ತದೆ.

  • i = 3, ಮೈಸೆಟ್ = {1, 4, 45}, ಮೊತ್ತ = 16;

j = sum-arr [i];

ಅದು j = 16-6 = 10 ಮತ್ತು j ನಕ್ಷೆಯಲ್ಲಿ ಇರುವುದಿಲ್ಲ.

ಆದ್ದರಿಂದ ಇದು ಮೈಸೆಟ್‌ಗೆ '6' ಆಗಿರುವ ಅರ್ [i] ಅನ್ನು ಸೇರಿಸುತ್ತದೆ.

  • i = 4, ಮೈಸೆಟ್ = {1, 4, 45, 6}, ಮೊತ್ತ = 16;

j = sum-arr [i];

ಅದು j = 16-10 = 6 ಮತ್ತು j ನಕ್ಷೆಯಲ್ಲಿ ಇರುತ್ತದೆ.

ಜೋಡಿಯ ಮತ್ತೊಂದು ಅಂಶವನ್ನು ನಾವು ಇಲ್ಲಿ ಕಾಣುತ್ತೇವೆ. ನಾವು ಈಗಾಗಲೇ 16 ಮತ್ತು 10 ರಂದು ಕಾರ್ಯಾಚರಣೆ ನಡೆಸಿದ್ದೇವೆ.

ಮತ್ತು ನಾವು ಮುದ್ರಿಸುತ್ತೇವೆ:

“ಕೊಟ್ಟಿರುವ ಮೊತ್ತವನ್ನು 16 ಎಂದು ಕಂಡುಕೊಂಡ ಅಂಶಗಳು (10, 6);

ಅಂದರೆ ಎರಡು ಅಂಶಗಳು ರಚನೆಯಲ್ಲಿ ಇರುತ್ತವೆ, ಅದು “ಮೊತ್ತ” ಕ್ಕೆ ಸಮಾನವಾದ ಮೊತ್ತವನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ಅನುಷ್ಠಾನ

ಕೊಟ್ಟಿರುವ ಮೊತ್ತದೊಂದಿಗೆ ಕೌಂಟ್ ಜೋಡಿಗಾಗಿ ಸಿ ++ ಪ್ರೋಗ್ರಾಂ

#include <bits/stdc++.h>
using namespace std;

void getPairOfSum(int arr[], int arr_size, int sum)
{
    unordered_set<int> myset;
    for (int i = 0; i < arr_size; i++)
    {
        int j = sum - arr[i];
        if (myset.find(j) != myset.end())
        {
            cout << "Found elements with the given sum as "<<sum << " is (" << arr[i] <<", " << j << ")"<<endl;
        }
        myset.insert(arr[i]);
    }
}
int main()
{
    int arr[] = { 1, 4, 45, 6, 10, 8 };
    int sum = 16;
    int arr_size = sizeof(arr) / sizeof(arr[0]);
    getPairOfSum(arr, arr_size, sum);
    return 0;
}
Found elements with the given sum as 16 is (10, 6)

ಕೊಟ್ಟಿರುವ ಮೊತ್ತದೊಂದಿಗೆ ಕೌಂಟ್ ಜೋಡಿಗಾಗಿ ಜಾವಾ ಪ್ರೋಗ್ರಾಂ

import java.io.*;
import java.util.HashSet;

class twoElementSum {
  public static void getPairOfSum(int arr[], int sum) {
    HashSet<Integer> myset = new HashSet<Integer> ();
    for (int i = 0; i<arr.length; ++i) {
      int j = sum - arr[i];
      if (myset.contains(j)) {
        System.out.println("Found elements with the given sum as " + sum + " is (" + arr[i] + ", " + j + ")");
      }
      myset.add(arr[i]);
    }
  }
  public static void main(String[] args) {
    int arr[] = { 1, 4, 45, 6, 10, 8 };
    int sum = 16;
    getPairOfSum(arr, sum);
  }
}
Found elements with the given sum as 16 is (10, 6)

ಕೊಟ್ಟಿರುವ ಮೊತ್ತದೊಂದಿಗೆ ಕೌಂಟ್ ಜೋಡಿಗೆ ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

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

ಓ (ಎನ್) ಇಡೀ ಶ್ರೇಣಿಯನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಹಾದುಹೋಗುವ ಅಗತ್ಯವಿರುತ್ತದೆ.

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

ಓ (ಎನ್) ರಚನೆಯ ಅಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಹ್ಯಾಶ್ ನಕ್ಷೆಯನ್ನು ಬಳಸಲಾಗಿದೆ.

ರೆಫರೆನ್ಸ್