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


שוועריקייט לעוועל גרינג
אָפט געבעטן אין באַנקבאַזאַר סיסקאָ ציטאַדעל האָנייוועלל PayU ראָבלאָקס טאַקסי 4 זיכער יאַנדעקס
מענגע האַש סאָרטינג סטל

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

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

בייַשפּיל  

arr1[] = {1, 6, 8, 11}

arr2[] = {1, 3, 5, 9}

sum = 9
2

 

דערקלערונג: ווייַל עס זענען גאַנץ 2 פּערז אין אַ געגעבן מענגע וואָס איז (6, 3) און (8, 1). ווייַל אנדערע פּערז האָבן אַ סומע אָדער גרעסערע אָדער ווייניקער ווי די פארלאנגט סאַכאַקל.

arr1[] = {3, 5, 11, 14};

arr2[] = {2, 4, 5, 11}

sum = 16
3

 

דערקלערונג: ווייַל עס זענען גאַנץ 3 פּערז אין די געגעבן מענגע וואָס איז (5, 11), (11, 5), און (14, 2).

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

1. Set count and left to 0, and right to n-1 where n is the length of the array.
2. While left is less than m and right is greater than equal to 0, repeat the following the steps-
    1. If the sum of arr[left] and arr[right] is equal to the given value, then increase the value of count and left by 1 and decrease the value of right by 1.
    2. Else check if the addition of arr[left] and arr[right] is less than the given value sum, then increase the value of left by 1.
    3. Decrease the value of right by 1 if the addition is greater than the sum.
3. Return the count value after traversing the arrays.

דערקלערונג

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

זע אויך
פּלאַן פּאַרקינג סיסטעם לעעטקאָדע סאַלושאַן

מיר וועלן שטעלן די ווערט פון ציילן צו 0. ווייַל מיר וועלן פאַרגרעסערן דעם נומער פון ציילן מיט 1 אויב מיר געפֿינען די פארלאנגט פּאָר. א פּאָר וועט זיין קאַנסיסטינג פון צוויי וואַלועס. דאָך מיר וועלן קאָנטראָלירן אויב די דערצו פון די ווערט אין אַ פּאָר איז גלייַך צו די געגעבן ווערט סאַכאַקל. אויב עס איז אמת, מיר וועלן פאַרגרעסערן די ווערט פון ציילן מיט 1. מיר וועלן לויפן אַ בשעת שלייף אין דעם שטייגער. דערנאָך עס וועט גיין ביז די וואַלועס פון m (m איז די לענג פון איינער פון די מענגע) און r (ווו r איז איינער ווייניקער ווי די לענג פון אַ מענגע) איז גרעסער ווי גלייַך צו 0.

אין אַ שלייף, מיר וועלן קאָנטראָלירן צי די ווערט פון די פּאָר מוסיף אַרויף צו די געגעבן ווערט. דערנאָך מיר האָבן געפֿונען איין פּאָר ווען דער צושטאַנד ווערט אמת. מיר וועלן פאָרזעצן די שלייף אויב די סומע איז ווייניקער ווי די געגעבן ווערט. דערנאָך מיר וועלן פאַרגרעסערן די ווערט פון l דורך 1 אַנדערש מיר נאָר פאַרמינערן די ווערט פון r צום סוף, מיר וועלן צוריקקומען די ווערט פון ציילן.

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

קאָדעקס  

C ++ קאָד צו ציילן פּערז וועמענס סומע איז X פֿון צוויי סאָרטעד ערייז

#include<iostream>

using namespace std;

int getPairofsum(int arr1[], int arr2[], int m, int n, int sum)
{
    int count = 0;
    int left = 0, right = n - 1;

    while (left < m && right >= 0)
    {
        if ((arr1[left] + arr2[right]) == sum)
        {
            left++;
            right--;
            count++;
        }
        else if ((arr1[left] + arr2[right]) < sum)
            left++;
        else
            right--;
    }
    return count;
}
int main()
{
    int arr1[] = {1, 6, 8, 11};
    int arr2[] = {1, 3, 5, 9};
    int m = sizeof(arr1) / sizeof(arr1[0]);
    int n = sizeof(arr2) / sizeof(arr2[0]);
    int sum = 9;
    cout << "Count = "<< getPairofsum(arr1, arr2, m, n, sum);
    return 0;
}
Count = 2

 

זע אויך
קייט סומע קוויריז אָן דערהייַנטיקונגען

Java קאָד צו ציילן פּערז וועמענס סומע איז X פֿון צוויי סאָרטעד ערייז

class PairofSum
{
    public static int getPairofsum(int arr1[],int arr2[], int m, int n, int sum)
    {
        int count = 0;
        int left = 0, right = n - 1;

        while (left < m && right >= 0)
        {
            if ((arr1[left] + arr2[right]) == sum)
            {
                left++;
                right--;
                count++;
            }
            else if ((arr1[left] + arr2[right]) < sum)
                left++;
            else
                right--;
        }
        return count;
    }
    public static void main (String[] args)
    {
        int arr1[] = {1, 6, 8, 11};
        int arr2[] = {1, 3, 5, 9};
        int m = arr1.length;
        int n = arr2.length;
        int sum = 9;
        System.out.println( "Count = "+ getPairofsum(arr1, arr2, m, n, sum));
    }
}
Count = 2

 

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

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

אָ (m + n) ווו "עם" און “N” איז די נומער פון עלעמענטן אין די arr1 און arr2. ווייַל די מאַקס וואָס מיר קענען אַרומפאָרן איז m + n.

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

אָ (1) ווי קיין עקסטרע פּלאַץ איז פארלאנגט. אזוי אַ קעסיידערדיק פּלאַץ קאַמפּלעקסיטי איז אַטשיווד.