ציילן קוואַדרופּאַלז פון פיר סאָרטירט ערייז וועמענס סומע איז גלייַך צו אַ געגעבן ווערט x


שוועריקייט לעוועל מיטל
אָפט געבעטן אין אַקקאָליטע פאנאטיקערס מאָנפראָג לאַבס סינאָפּסיס
מענגע ביינערי זוכן האַש שאַרף סאָרטינג

פּראָבלעם סטאַטעמענט

פּראָבלעם "ציילן קוואַדרופּאַלז פון פיר סאָרטירט ערייז וועמענס סאַכאַקל איז גלייַך צו אַ געגעבן ווערט x" שטאַט אַז איר באַקומען פיר ינטאַדזשער ערייז און אַ ווערט גערופֿן x. די פּראָבלעם ויסזאָגונג פרעגט צו געפֿינען אויס ווי פילע קוואדרופּלעץ קענען ווערן געשאפן פון וואָס סומע פון ​​עלעמענטן פון יעדער קוואַדרופּלעט קען האָבן אַ דערצו צו די געגעבן ווערט גערופֿן x.

בייַשפּיל

int arr1[] = { 2, 5, 6, 9 };

int arr2[] = { 1, 3, 7, 11 };

int arr3[] = { 1, 5, 6, 8 };

int arr4[] = { 2, 3, 5, 10 };

Sum=32
5

דערקלערונג: עס זענען 5 קוואַדרופּלעץ וואָס קענען סאַכאַקל צו געבן די פארלאנגט ווערט x = 5.

 

אַלגערידאַם צו ציילן קוואַדרופּאַלז פֿון פיר סאָרטירט ערייז וועמענס סומע איז רענטגענ

1. Set the value of count to 0.
2. Declare a map.
3. Traverse the first and second list and store the sum of each pair that can be formed with the two lists into the map along with their frequency.
4, Traverse the other two arrays.
    1. Pick a sum of each pair from the two arrays and check if the x-sum is present in a map.
        1. If present then gets their frequency and add it to the value of count.
5. Return count.

דערקלערונג

מיר האָבן געגעבן פיר ערייז פון גאַנץ נומערן און אַ נומער x. אונדזער אַרבעט איז צו געפֿינען די גאַנץ נומער פון קוואַדרופּלעץ וואָס קענען זיין געשאפן, וואָס איז גלייַך צו די x. פֿאַר וואָס מיר וועלן נוצן כאַשינג. מיר וועלן נוצן אַ מאַפּע דערפֿאַר, אין דעם וועג, עס וועט צושטעלן אַן עפעקטיוו צוגאַנג צו סאָלווע די קשיא.

באַשטעטיק די ווערט פון ציילן צו 0, די ציילן בייַטעוודיק וועט קראָם די נומער פון קוואדרופּלעץ. מיר וועלן דערקלערן אַ מאַפּע. אָנהייבן אַריבער די ערשטע צוויי ערייז און קראָם די סומע פון ​​יעדער פּאָר פון ערשטער צוויי ערייז אין דער מאַפּע ווי אַ שליסל און שטעלן די אָפטקייַט פון יעדער סומע ווי אַ ווערט פון די שליסל אין די מאַפּע. אויב מיר געפֿינען אן אנדער פּאָר פון אַ ענלעך ווערט פון די סומע. מיר פּונקט פאַרגרעסערן די ווערט פון די סומע אָפטקייַט. נאָך די גאַנץ דורכפאָר פון די ערשטע צוויי ערייז, מיר האָבן אַ סומע פון ​​פּערז פון די ערשטע צוויי ערייז.

איצט מיר וועלן נעמען צוויי אנדערע ערייז דורך, מיר וועלן קלייַבן די סומע פון ​​צוויי יסודות פון יעדער פּאָר פון אַ מענגע. איין נומער פון איין מענגע און איין נומער פון אנדערן. דערנאָך מיר וועלן קאָנטראָלירן צי די חילוק פון x און די סומע פון ​​דעם פּאָר איז פאָרשטעלן אין אַ מאַפּע. דערנאָך מיר באַקומען די אָפטקייַט פון די פּאָר פֿון די מאַפּע. אויב פאָרשטעלן, מיר פאַרגרעסערן די ציילן פון ציילן דורך לייגן די אָפטקייַט צו די ציילן, וואָס מיטל מיר האָבן געפֿונען איין קוואַדרופּלעט פֿון אַלע ערייז. דאָס איז ווייַל אויב מיר האָבן 10 + 20 = 30, מיר קענען אויך געפֿינען איינער פון די וואַלועס ווי 30-10 איז וואָס, ענלעך איז געשעעניש צו דעם לייזונג, און לעסאָף, מיר וועלן צוריקקומען די ווערט פון ציילן.

ציילן קוואַדרופּאַלז פון פיר סאָרטירט ערייז וועמענס סומע איז גלייַך צו אַ געגעבן ווערט x

קאָדעקס

C ++ קאָד צו ציילן קוואַדרופּאַלז פון פיר סאָרטירט ערייז וועמענס סומע איז גלייַך צו אַ געגעבן ווערט x

#include <iostream>
#include<unordered_map>

using namespace std;

int getNumberOfQuadruples(int arr1[], int arr2[], int arr3[],int arr4[], int n, int x)
{
    int count = 0;

    unordered_map<int, int> MAP;

    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            MAP [arr1[i] + arr2[j]]++;

    for (int k = 0; k < n; k++)
        for (int l = 0; l < n; l++)
        {
            int p_sum = arr3[k] + arr4[l];

            if (MAP.find(x - p_sum) != MAP.end())
                count += MAP [x - p_sum];
        }

    return count;
}
int main()
{
    int arr1[] = { 2, 5, 6, 9 };
    int arr2[] = { 1, 3, 7, 11 };
    int arr3[] = { 1, 5, 6, 8 };
    int arr4[] = { 2, 3, 5, 10 };

    int n = sizeof(arr1) / sizeof(arr1[0]);
    int x = 32;
    cout << "Count = "<< getNumberOfQuadruples (arr1, arr2, arr3, arr4, n, x);
    return 0;
}
Count = 3

Java קאָד צו ציילן קוואַדרופּאַלז פון פיר סאָרטירט ערייז וועמענס סומע איז גלייַך צו אַ געגעבן ווערט x

import java.util.HashMap;

class QuadrupletsSum
{
    public static int getNumberOfQuadruples (int arr1[], int arr2[], int arr3[], int arr4[], int n, int x)
    {
        int count = 0;

        HashMap<Integer,Integer> MAP = new HashMap<>();

        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                if(MAP.containsKey(arr1[i] + arr2[j]))
                    MAP.put((arr1[i] + arr2[j]), MAP.get((arr1[i] + arr2[j]))+1);
                else
                    MAP.put((arr1[i] + arr2[j]), 1);

        for (int k = 0; k < n; k++)
            for (int l = 0; l < n; l++)
            {
                int p_sum = arr3[k] + arr4[l];

                if (MAP.containsKey(x - p_sum))
                    count += MAP.get(x - p_sum);
            }

        return count;
    }
    public static void main(String[] args)
    {
        int arr1[] = { 2, 5, 6, 9 };
        int arr2[] = { 1, 3, 7, 11 };
        int arr3[] = { 1, 5, 6, 8 };
        int arr4[] = { 2, 3, 5, 10 };

        int n = arr1.length;
        int x = 32;
        System.out.println("Count = "
                           + getNumberOfQuadruples (arr1, arr2, arr3, arr4, n, x));
    }
}
Count = 3

קאַמפּלעקסיטי אַנאַליסיס

צייט קאַמפּלעקסיטי

אָ (n2ווו “N” איז די נומער פון עלעמענטן אין די מענגע. מיר האָבן אַטשיווד די פּאַלינאָומיאַל צייט קאַמפּלעקסיטי פון N ^ 2 ווייַל מיר דורכגעקאָכט בלויז די יסודות פון צוויי ערייז יעדער מאָל.

ספעיס קאַמפּלעקסיטי

אָ (n2ווו “N” איז די נומער פון עלעמענטן אין די מענגע. זינט די נומער פון עלעמענטן וואָס זענען סטאָרד אין די HashMap, עס זענען די יסודות פון צוויי ערייז. מיר דערגרייכן קוואַדראַטיק אָרט קאַמפּלעקסיטי.