ಅರೇನಲ್ಲಿ ಅತಿದೊಡ್ಡ ಡಿ ಅನ್ನು ಹುಡುಕಿ ಅಂದರೆ + ಬಿ + ಸಿ = ಡಿ


ತೊಂದರೆ ಮಟ್ಟ ಮಧ್ಯಮ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಕೋಲೈಟ್ ಅಮೆಜಾನ್ ದೆಹಲಿ ಫ್ಯಾನಟಿಕ್ಗಳು ಫೋರ್‌ಕೈಟ್‌ಗಳು ಫ್ರೀಚಾರ್ಜ್
ಅರೇ ಹ್ಯಾಶ್

ಸಮಸ್ಯೆ ಹೇಳಿಕೆ

ನೀವು ಹೊಂದಿದ್ದೀರಿ ಎಂದು ಭಾವಿಸೋಣ ಸರಣಿ of ಪೂರ್ಣಾಂಕಗಳು. ಇನ್ಪುಟ್ ಮೌಲ್ಯಗಳು ಎಲ್ಲಾ ವಿಭಿನ್ನ ಅಂಶಗಳಾಗಿವೆ. "ಶ್ರೇಣಿಯಲ್ಲಿ ಅತಿದೊಡ್ಡ ಡಿ ಅನ್ನು ಹುಡುಕಿ, ಅಂದರೆ + ಬಿ + ಸಿ = ಡಿ" ಸೆಟ್ನಲ್ಲಿ ಅತಿದೊಡ್ಡ ಅಂಶ 'ಡಿ' ಅನ್ನು ಕಂಡುಹಿಡಿಯಲು ಕೇಳುತ್ತದೆ, ಅಂದರೆ + ಬಿ + ಸಿ = ಡಿ, ಅಲ್ಲಿ ಎಲ್ಲಾ ಅಂಶಗಳು ಪರಸ್ಪರ ಭಿನ್ನವಾಗಿರುತ್ತವೆ.

ಉದಾಹರಣೆ

arr[] = {1, 4, 6, 8, 11 }
11

ವಿವರಣೆ: ಎ, ಬಿ ಮತ್ತು ಸಿ ಎಂಬ ಮೂರು ಸಂಖ್ಯೆಗಳು 1, 4 ಮತ್ತು 6 ಮತ್ತು ಅವುಗಳ ಮೊತ್ತ 11 ಆಗಿದೆ.

arr[] = {2,4,6,10,15 }
No such solution exists.

ವಿವರಣೆ: ಮೂರು ಸಂಖ್ಯೆಗಳಿಲ್ಲದ ಕಾರಣ, ಅದು ಒಂದು ಸಂಖ್ಯೆಯವರೆಗೆ ಒಟ್ಟುಗೂಡಿಸುತ್ತದೆ.

ಕ್ರಮಾವಳಿ

1. Declare a Map.
2. While traversing through the array.
    1. Add and insert the sum of two elements in a map with their indexes in a Map.
3. Set the number to the minimum value of an integer, which we have to find out.
4. Search for the third number in a map by checking the difference of two numbers is present in a map.
5. If true then check if their indexes should not be the same.
6. Check for the maximum of d and the maximum of arr[i] and arr[j] and store it to d.
7. Return d.

ವಿವರಣೆ

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

ನಾವು ಜೋಡಿಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತೇವೆ ಏಕೆಂದರೆ ನಾವು d ಗಾಗಿ ಹುಡುಕುತ್ತಿದ್ದೇವೆ, ಅಂದರೆ a + b + c = d. ಇದರ ಬದಲಾಗಿ, ನಾವು + b = d - c ಗಾಗಿ ಹುಡುಕುತ್ತೇವೆ. ಆದ್ದರಿಂದ ಮೊದಲಿಗೆ, ನಾವು ಜೋಡಿಯನ್ನು ಮತ್ತು ಅವುಗಳ ಸೂಚ್ಯಂಕಗಳನ್ನು ಸಂಗ್ರಹಿಸಿದಾಗ. ನಕ್ಷೆಯಲ್ಲಿ d - c ಅಸ್ತಿತ್ವದಲ್ಲಿರುವಂತಹ 'd' ಅಂಶವನ್ನು ನಾವು ಪರಿಶೀಲಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ರಚನೆಯನ್ನು ಹಾದುಹೋಗುವ ಮೂಲಕ ಮತ್ತು ನಂತರ ಎರಡು ಅಂಶಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ತೆಗೆದುಕೊಳ್ಳುವ ಮೂಲಕ ಇದನ್ನು ಮಾಡಬಹುದು. ಎರಡೂ ಅಂಶಗಳ ವ್ಯತ್ಯಾಸವನ್ನು ಮಾಡಿ ಮತ್ತು ನಕ್ಷೆಯಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ ಆ ವ್ಯತ್ಯಾಸವನ್ನು ಹುಡುಕಿ. ಇದು ನಿಜವೆಂದು ಕಂಡುಬಂದಲ್ಲಿ, ಪ್ರಸ್ತುತ ಎರಡು ಅಂಶಗಳು ಸೂಚ್ಯಂಕದಲ್ಲಿನ ಹಿಂದಿನ ಜೋಡಿಗಳಂತೆಯೇ ಇರಬಾರದು ಎಂದು ಪರಿಶೀಲಿಸಿ.

ಒಂದೇ ಸೂಚ್ಯಂಕದಲ್ಲಿ ಯಾವುದೇ ಅಂಶಗಳನ್ನು ಪುನರಾವರ್ತಿಸಬಾರದು ಎಂದು ಪರಿಶೀಲಿಸಲು ಇದು ಅವಶ್ಯಕವಾಗಿದೆ, ಪುನರಾವರ್ತಿತ ಸಂಖ್ಯೆಯನ್ನು ಎ, ಬಿ, ಸಿ ಮತ್ತು ಡಿಗಳಲ್ಲಿ ಪರಿಗಣಿಸಬಹುದು, ಆದರೆ ಅವುಗಳ ಸೂಚ್ಯಂಕಗಳು, ಅಂದರೆ, ಅದೇ ಸೂಚ್ಯಂಕದಲ್ಲಿರುವ ಸಂಖ್ಯೆಯನ್ನು ಸ್ವತಃ ಮಾಡಬೇಕು ಪರಿಗಣಿಸಲಾಗುವುದಿಲ್ಲ. ಆದ್ದರಿಂದ ನಾವು ಆ ಸೂಚ್ಯಂಕಗಳ ಕೃತಿಚೌರ್ಯವನ್ನು ಪರಿಶೀಲಿಸಬೇಕಾಗಿದೆ. ಈಗ, ನಾವು ಗರಿಷ್ಠ arr [i] ಮತ್ತು arr [j] ಗಳನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕು ಮತ್ತು ಅವುಗಳ ನಡುವೆ ಗರಿಷ್ಠವನ್ನು ಕಂಡುಹಿಡಿಯಲು ಮತ್ತು ಅದನ್ನು d ಗೆ ಸಂಗ್ರಹಿಸಲು ಗರಿಷ್ಠ d ಗೆ ಪರಿಶೀಲಿಸಿ. ಏಕೆಂದರೆ, ನಾವು ನಾಲ್ಕನೇ ಸಂಖ್ಯೆ d ಅನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕಾಗಿದೆ, ಆದ್ದರಿಂದ ನಾವು a, b, c ಮತ್ತು d ಗಳ ನಡುವೆ d ಯಾವಾಗಲೂ ದೊಡ್ಡದಾಗಿರುವುದರಿಂದ ಗರಿಷ್ಠ ಶ್ರೇಣಿಯ ಅಂಶಗಳನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕು.

ಅನುಷ್ಠಾನ

+ B + c = d ನಂತಹ ದೊಡ್ಡ ಡಿ ಅನ್ನು ಶ್ರೇಣಿಯಲ್ಲಿ ಕಂಡುಹಿಡಿಯಲು ಸಿ ++ ಪ್ರೋಗ್ರಾಂ

#include<iostream>
#include<unordered_map>

using namespace std;

int getSumThreeNumber(int arr[], int n)
{
    unordered_map<int, pair<int, int> > MAP;
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = i + 1; j < n; j++)
        {
            MAP[arr[i] + arr[j]] = { i, j };
        }
    }
    int d_number = INT_MIN;
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = i + 1; j < n; j++)
        {
            int third = abs(arr[i] - arr[j]);

            if (MAP.find(third) != MAP.end())
            {
                pair<int, int> obj = MAP[third];
                if (obj.first != i && obj.first != j && obj.second != i && obj.second != j)
                    d_number = max(d_number, max(arr[i], arr[j]));
            }
        }
    }
    return d_number;
}
int main()
{
    int arr[] = { 1,4,6,8,11 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int res = getSumThreeNumber(arr, n);
    if (res == INT_MIN)
        cout << "No such solution exists";
    else
        cout << res;
    return 0;
}
11

ಅರೇನಲ್ಲಿ ಅತಿದೊಡ್ಡ ಡಿ ಅನ್ನು ಕಂಡುಹಿಡಿಯಲು ಜಾವಾ ಪ್ರೋಗ್ರಾಂ ಅಂದರೆ + ಬಿ + ಸಿ = ಡಿ

import java.util.HashMap;

class CheckIndex
{
    int i, j;

    CheckIndex(int i, int j)
    {
        this.i = i;
        this.j = j;
    }
    int checkI()
    {
        return i;
    }

    int checkJ()
    {
        return j;
    }
}

class sumOfThreeElementToD
{

    public static int getSumThreeNumber(int[] arr, int n)
    {
        HashMap<Integer, CheckIndex> map = new HashMap<>();

        for (int i = 0; i < n - 1; i++)
        {
            for (int j = i + 1; j < n; j++)
            {
                map.put(arr[i] + arr[j], new CheckIndex(i, j));
            }
        }

        int d_number = Integer.MIN_VALUE;

        for (int i = 0; i < n - 1; i++)
        {
            for (int j = i + 1; j < n; j++)
            {
                int third = Math.abs(arr[i] - arr[j]);

                if (map.containsKey(third))
                {
                    CheckIndex ci = map.get(third);
                    if (ci.checkI() != i && ci.checkI() != j && ci.checkJ() != i && ci.checkJ() != j)
                    {
                        d_number = Math.max(d_number, Math.max(arr[i], arr[j]));
                    }
                }
            }
        }
        return d_number;
    }
    public static void main(String[] args)
    {
        int arr[] = { 1, 4, 6, 8, 11 };
        int n = arr.length;
        int output = getSumThreeNumber(arr, n);
        if (output == Integer.MIN_VALUE)
            System.out.println("No such solution exists");
        else
            System.out.println(output);
    }
}
11

ಅರೇನಲ್ಲಿ ಅತಿದೊಡ್ಡ ಡಿ ಅನ್ನು ಕಂಡುಹಿಡಿಯಲು ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ ಅಂದರೆ + ಬಿ + ಸಿ = ಡಿ

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

ಒ (ಎನ್2ಅಲ್ಲಿ “ಎನ್” ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆ. ನಾವು ಈ ಸಂಕೀರ್ಣತೆಯನ್ನು ಸಾಧಿಸಿದ್ದೇವೆ ಏಕೆಂದರೆ ನಾವು ಹ್ಯಾಶ್‌ಮ್ಯಾಪ್ ಅನ್ನು ಬಳಸಿದ್ದೇವೆ ಅದು ಒ (1) ಸಮಯದಲ್ಲಿ ಅಳವಡಿಕೆ ಶೋಧ ಮತ್ತು ಇತರ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಅನುಮತಿಸುತ್ತದೆ.

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

ಒ (ಎನ್2) ಅಲ್ಲಿ “ಎನ್” ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆ. ಹ್ಯಾಶ್‌ಮ್ಯಾಪ್ ಇನ್‌ಪುಟ್‌ನ ವಿಭಿನ್ನ ಅಂಶಗಳ ಜೋಡಿಯನ್ನು ಸಂಗ್ರಹಿಸುವುದರಿಂದ. ಈ ಕಾರಣದಿಂದಾಗಿ, ಅಲ್ಗಾರಿದಮ್ ಚತುರ್ಭುಜ ಸ್ಥಳ ಸಂಕೀರ್ಣತೆಯನ್ನು ಹೊಂದಿದೆ.

ರೆಫರೆನ್ಸ್