ಎರಡು ಮೊತ್ತ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಆಪಲ್ ಬೈಟ್ ಡೇನ್ಸ್ ಪ್ರತ್ಯಕ್ಷ ಮೈಕ್ರೋಸಾಫ್ಟ್ ಒರಾಕಲ್
ಬೈನರಿ ಹುಡುಕಾಟ ಎರಡು ಪಾಯಿಂಟರ್

ಈ ಸಮಸ್ಯೆಯಲ್ಲಿ, ನಾವು ಎರಡು ವಿಭಿನ್ನ ಸೂಚ್ಯಂಕಗಳ ಜೋಡಿಯನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕು ವಿಂಗಡಿಸಲಾಗಿದೆ ಸರಣಿ ಅವುಗಳ ಮೌಲ್ಯಗಳು ನಿರ್ದಿಷ್ಟ ಗುರಿಯನ್ನು ಸೇರಿಸುತ್ತವೆ. ರಚನೆಯು ಮಾತ್ರ ಹೊಂದಿದೆ ಎಂದು ನಾವು can ಹಿಸಬಹುದು ಒಂದು ಗುರಿ ಮೊತ್ತಕ್ಕೆ ಸೇರಿಸುವ ಪೂರ್ಣಾಂಕಗಳ ಜೋಡಿ. ರಚನೆಯನ್ನು a ನಲ್ಲಿ ವಿಂಗಡಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ ಕಡಿಮೆಯಾಗುವುದಿಲ್ಲ ರೀತಿಯಲ್ಲಿ.

ಉದಾಹರಣೆ

Array = {1 , 2 , 3 , 4 , 5}
Target = 6
1 5
Array = {1 , 4 , 5 , 11 , 12}
Target = 9
2 3

ಅಪ್ರೋಚ್ (ವಿವೇಚನಾರಹಿತ ಶಕ್ತಿ)

ಈ ವಿಧಾನವು ನೇರವಾಗಿರುತ್ತದೆ. ರಚನೆಯ ಪ್ರತಿಯೊಂದು ಜೋಡಿಯನ್ನು ನಾವು ಪರಿಶೀಲಿಸಬಹುದು ಮತ್ತು ಅವುಗಳ ಮೊತ್ತವು ನಿರ್ದಿಷ್ಟ ಗುರಿಗೆ ಸಮನಾಗಿದ್ದರೆ, ಅವರ ಸೂಚ್ಯಂಕಗಳನ್ನು ಮುದ್ರಿಸಿ. ಈ ರೀತಿಯ ವಿವೇಚನಾರಹಿತ ಪಡೆ ಪರಿಹಾರವು ರಚನೆಯಲ್ಲಿ ಸಂಭವನೀಯ ಜೋಡಿ ಮತ್ತು ಸಂಭವನೀಯ ಜೋಡಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪರಿಶೀಲಿಸುವ ಅಗತ್ಯವಿದೆ n * (n - 1) / 2. ಆದ್ದರಿಂದ, ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ, ಈ ವಿಧಾನವು ನಿಧಾನವಾಗಿರುತ್ತದೆ.

ಕ್ರಮಾವಳಿ

  1. ರಚನೆಯಲ್ಲಿ ಪರಿಹಾರದ ಮೊದಲ ಸೂಚಿಯನ್ನು ನಿರ್ವಹಿಸಲು ಲೂಪ್ ಅನ್ನು ಚಲಾಯಿಸಿ
  2. ಪ್ರತಿ ಮೊದಲ ಪೂರ್ಣಾಂಕಕ್ಕೆ ಪರಿಹಾರದ ಎರಡನೇ ಸೂಚಿಯನ್ನು ನಿರ್ವಹಿಸಲು ಮತ್ತೊಂದು ಲೂಪ್ ಅನ್ನು ಚಲಾಯಿಸಿ
  3. ಯಾವುದೇ ಹಂತದಲ್ಲಿ, ಎರಡು ಸೂಚ್ಯಂಕಗಳ ಮೌಲ್ಯಗಳ ಮೊತ್ತವು ಗುರಿಗೆ ಸಮಾನವಾಗಿರುತ್ತದೆ
    • ಅದರ ಸೂಚ್ಯಂಕಗಳನ್ನು ಮುದ್ರಿಸಿ

ಎರಡು ಮೊತ್ತದ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದ ಅನುಷ್ಠಾನ

ಸಿ ++ ಪ್ರೋಗ್ರಾಂ

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

vector <int> targetSum(vector <int> &a , int &target)
{
    int n = a.size();
    for(int i = 0 ; i < n - 1 ; i++)
        for(int j = i + 1 ; j < n ; j++)
        {
            if(a[i] + a[j] == target)
                return {i + 1 , j + 1};
        }
    return {};
}

int main()
{
    vector <int> a = {1 , 4 , 5 , 11 , 12};
    int target = 9;
    for(int &x : targetSum(a , target))
        cout << x << " ";
    cout << '\n';
}

ಜಾವಾ ಪ್ರೋಗ್ರಾಂ

class target_sum
{
    static int[] targetSum(int []a , int target)
    {
        for(int i = 0 ; i < a.length - 1 ; i++)
            for(int j = i + 1 ; j < a.length ; j++)
            {
                if(a[i] + a[j] == target)
                    return new int[]{i + 1 , j + 1};
            }
        return new int[]{-1 , -1};
    }


    public static void main(String args[])
    {
        int [] a = {1 , 4 , 5 , 11 , 12};
        int target = 9;

        for(int x : targetSum(a , target))
            System.out.print(x + " ");
    }
}
2 3

ಎರಡು ಮೊತ್ತದ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದ ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

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

ಒ (ಎನ್ * ಎನ್), ಅಲ್ಲಿ ರಚನೆಯ N = ಗಾತ್ರ. ಸಂಭವನೀಯ ಜೋಡಿಯನ್ನು ನಾವು ಪರಿಶೀಲಿಸುತ್ತಿದ್ದಂತೆ, ಮತ್ತು ಒಟ್ಟು ಜೋಡಿಗಳ ಸಂಖ್ಯೆ: ಎನ್ * (ಎನ್ - 1) / 2.

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

ಒ (1). ಅಸ್ಥಿರಗಳಿಗೆ ಸ್ಥಿರವಾದ ಜಾಗವನ್ನು ಮಾತ್ರ ಬಳಸಲಾಗುತ್ತದೆ.

ಅಪ್ರೋಚ್ (ಎರಡು ಪಾಯಿಂಟರ್)

ಕ್ರಮಾವಳಿ

ಗಿವ್ ಅರೇ ಆಗಿದೆ ವಿಂಗಡಿಸಲಾಗಿದೆ. ಇದು ವಿಶೇಷ ಸಂದರ್ಭವಾಗಿದೆ ಏಕೆಂದರೆ ನಾವು ಮೊದಲ ಸೂಚ್ಯಂಕವನ್ನು ನಿಗದಿಪಡಿಸಿದರೆ ಗುರಿಯನ್ನು ಪೂರೈಸಲು ಅಗತ್ಯವಾದ ಮೌಲ್ಯವು ರಚನೆಯಲ್ಲಿ ಮುಂದೆ ಕಂಡುಬರುತ್ತದೆ ಬೈನರಿ ಹುಡುಕಾಟ. 

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

ವಿಂಗಡಿಸಲಾದ ಅರೇ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಗಳಲ್ಲಿ ಗುರಿಯನ್ನು ಸೇರಿಸುವ ಎರಡು ಪೂರ್ಣಾಂಕಗಳು

ಅನುಷ್ಠಾನ ಎರಡು ಮೊತ್ತ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ

ಸಿ ++ ಪ್ರೋಗ್ರಾಂ

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

vector <int> targetSum(vector <int> &a , int &target)
{
    int left = 0 , right = int(a.size()) - 1 , tempSum;
    while(left < right)
    {
        tempSum = a[left] + a[right];
        if(tempSum == target)
            return {left + 1 , right + 1};
        if(tempSum > target)
            right--;
        else
            left++;
    }
    return {-1 , -1};
}

int main()
{
    vector <int> a = {1 , 4 , 5 , 11 , 12};
    int target = 9;
    for(int &x : targetSum(a , target))
        cout << x << " ";
    cout << '\n';
}

ಜಾವಾ ಪ್ರೋಗ್ರಾಂ

class target_sum
{
    static int[] targetSum(int []a , int target)
    {
        int left = 0 , right = a.length - 1 , tempSum;
        while(left < right)
        {
            tempSum = a[left] + a[right];
            if(tempSum == target)
                return new int[]{left + 1 , right + 1};
            if(tempSum > target)
                right--;
            else
                left++;
        }
        return new int[]{-1 , -1};
    }


    public static void main(String args[])
    {
        int [] a = {1 , 4 , 5 , 11 , 12};
        int target = 9;

        for(int x : targetSum(a , target))
            System.out.print(x + " ");
    }
}
2 3

ಎರಡು ಮೊತ್ತದ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದ ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

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

ಒ (ಎನ್), ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ಸಹ, ನಾವು ರಚನೆಯ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಭೇಟಿ ಮಾಡುತ್ತೇವೆ.

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

ಒ (1). ನಾವು ಅಸ್ಥಿರಗಳಿಗಾಗಿ ಸ್ಥಿರ ಜಾಗವನ್ನು ಬಳಸುತ್ತೇವೆ.