ניט-אָוווערלאַפּינג סומע פון ​​צוויי שטעלט


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

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

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

בייַשפּיל

arrA[] = {1,3,4,5,2}
arrB[] = {2,4,6,7,8}
30

דערקלערונג

די יינציק עלעמענטן אין דער אויבן שטעלן פון די מענגע זענען 1, 3, 5, 6, 7 און 8.

גאַנץ סומע איז = 1+ 3 + 5 + 6 + 7 +8 = 30.

ניט-אָוווערלאַפּינג סומע פון ​​צוויי שטעלט

 

arrA[]={1,3,4,5,2}
arrB[]={3,4,1,5,7}
9

דערקלערונג

אַלע עלעמענטן זענען פּראָסט אַזוי אַז דער רעזולטאַט וועט זיין 0.

אַלגאָריטהם

  1. דערקלערן א מאַפּע.
  2. דורך די מענגע בשעת i <n (לענג פון די מענגע).
    1. ציילן און קראָם די פרעקווענסיעס פון ביידע עלעמענטן אין דער מאַפּע.
  3. שטעלן טאָוטאַלסאַם צו 0.
  4. דורכפאָר די מאַפּע.
    1. קאָנטראָלירן אויב די מאַפּע האט די ווערט פון די עלעמענט גלייַך צו 1.
      1. אויב אמת, האַלטן אַדינג אַלע די עלעמענטן אין די טאָוטאַלסאַם.
  5. Return totalSum.

 דערקלערונג

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

בייַשפּיל

לאמיר באטראכטן א ביישפיל: arrA [] = {1,3,4,5,2}, arrB [] = {2,4,6,7,8}

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

מאַפּע: {1: 1, 2: 2, 3: 1, 4: 2, 5: 1, 6: 1, 7: 1, 8: 1}.

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

טאָוטאַלסאַם = 0,

  • דער ערשטער עלעמענט '1' פון די מאַפּע האט 1 אָפטקייַט און לייג עס צו טאָוטאַל סאַם => טאָטאַל סום + שליסל = 0 + 1 = 1.
  • די רגע עלעמענט '2' פון די מאפע האט אָפטקייַט 2, אַזוי מיר וועלן נישט נעמען דעם שליסל ווייַל עס איז געוויינטלעך אין ביידע ערייז.
  • דער ערשטער עלעמענט '3' פון די מאַפּע האט 1 אָפטקייַט און לייג עס צו טאָוטאַל סאַם => טאָטאַל סום + שליסל = 1 + 3 = 4.
  • די רגע עלעמענט '4' פון די מאפע האט אָפטקייַט 2, אַזוי מיר וועלן נישט נעמען דעם שליסל ווייַל עס איז געוויינטלעך אין ביידע ערייז.
  • דער ערשטער עלעמענט '5' פון דער מאַפּע האט 1 אָפטקייַט, מיר לייגן עס צו טאָוטאַל סאַם => טאָוטאַל סאַם + שליסל = 4 + 5 = 9.

סימילאַרלי, מיר וועלן לייגן 6, 7 און 8 אין גאַנץ סאַם ווייַל אַלע האָבן די ווערט 1 ווי אַ אָפטקייַט. אַזוי עס וועט ווערן 1+ 3 + 5 + 6 + 7 +8 = 30.

רעזולטאַט: 30

קאָדעקס

ימפּלעמענטאַטיאָן אין C ++ פֿאַר נאַן-אָוווערלאַפּינג סומע פון ​​צוויי שטעלט

#include <unordered_map>
#include<iostream>

using namespace std;

int findSum(int arrA[], int arrB[], int n)
{
    unordered_map<int, int> map;
    for (int i = 0; i < n; i++)
    {
        map[arrA[i]]++;
        map[arrB[i]]++;
    }
    int totalSum = 0;
    for (auto sel: map)
        if (sel.second == 1)
            totalSum += sel.first;

    return totalSum;
}
int main()
{
    int arrA[] = { 5, 1, 10, 4, 7 };
    int arrB[] = { 1, 6, 7, 8, 2 };
    int l = sizeof(arrA) / sizeof(arrA[0]);
    cout << findSum(arrA, arrB, l);
    return 0;
}
35

ימפּלאַמענטיישאַן אין Java פֿאַר נאָן-אָוווערלאַפּינג סומע פון ​​צוויי שטעלט

import java.util.HashMap;
import java.util.Map;

class nonOverlappingSum
{
    public static int findSum(int[] A, int[] B, int n)
    {
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < n; i++)
        {
            if (map.containsKey(A[i]))
                map.put(A[i], map.get(A[i]) + 1);
            else
                map.put(A[i], 1);

            if (map.containsKey(B[i]))
                map.put(B[i], map.get(B[i]) + 1);
            else
                map.put(B[i], 1);
        }
        int totalSum = 0;
        for (Map.Entry entry : map.entrySet())
        {
            if (Integer.parseInt((entry.getValue()).toString()) == 1)
                totalSum += Integer.parseInt((entry.getKey()).toString());
        }
        return totalSum;

    }
    public static void main(String args[])
    {
        int arrA[] = { 5, 1, 10, 4, 7 };
        int arrB[] = { 1, 6, 7, 8, 2 };
        int l = arrA.length;
        System.out.println(findSum(arrA, arrB, l));
    }
}
35

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

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

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

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

אָ (N) ווו “N” איז די לענג פון די מענגע. ספעיס איז פארלאנגט צו קראָם די עלעמענטן פון ביידע ערייז אין מאַפּע.