နှစ်ခုအစုံ၏ Non- ထပ်ပေါင်းလဒ်  


ခက်ခဲအဆင့် လွယ်ကူသော
မကြာခဏမေးတယ် တိကျသော အမေဇုံ ခရီးသွား Kuliza Pinterest Snapdeal မြတ်နိုး Teradata
အခင်းအကျင်း တားဆီးခြင်း

ပြProbleနာဖော်ပြချက်  

ပြtwoနာက“ အစုံနှစ်ခုထပ်တူခြင်းမရှိသောပေါင်းလဒ်” ကသင့်အား arrAp နှစ်ခုကို input တန်ဖိုးများအဖြစ် arrA [] နှင့်အတူတူပင်အရွယ်အစား arrB [] ပေးသည်ဟုဖော်ပြသည်။ ထို့အပြင် Array နှစ်ခုလုံးတွင်သီးခြား element များနှင့်အချို့သော common element များရှိသည်။ ခင်ဗျားရဲ့တာ ၀ န်ကဘုံမဟုတ်တဲ့အရာအားလုံးစုစုပေါင်းကိုရှာဖို့ဖြစ်တယ်။

နမူနာ  

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

ရှင်းလင်းချက်

အထက်ပါအစုအဝေးရှိကွဲပြားခြားနားသောဒြပ်စင်များသည် ၁၊ ၃၊ ၅၊ ၆၊ ၇ နှင့် ၈ တို့ဖြစ်သည်။

စုစုပေါင်းငွေပမာဏ = 1+ 3 + 5 + 6 + 7 +8 = 30 ဖြစ်ပါတယ်။

နှစ်ခုအစုံ၏ Non- ထပ်ပေါင်းလဒ်

 

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

ရှင်းလင်းချက်

element အားလုံးသည်ဘုံဖြစ်တာကြောင့် output က 0 ဖြစ်မယ်။

algorithm  

  1. a) ကြေညာပါ မြေပုံ.
  2. ဖြတ်သန်း အခင်းအကျင်း ဈ <n (အခင်းကျင်း၏အရှည်) <နေစဉ်။
    1. array ၏ element များ၏ကြိမ်နှုန်းကိုရေတွက်။ သိမ်းဆည်းပါ။
  3. totalSum ကို 0 ထားပါ။
  4. မြေပုံကိုဖြတ်သွားပါ
    1. element ရဲ့တန်ဖိုးက 1 နဲ့ညီလားမသေချာဘူး။
      1. true ဖြစ်ပါက element များအားလုံးကိုစုစုပေါင်းထဲသို့ထည့်ပါ။
  5. totalSum သို့ပြန်သွားပါ။

 ရှင်းလင်းချက်

element အချို့ကိုတူညီသော input array နှစ်ခုကိုကျွန်ုပ်တို့ပေးထားသည်။ အဆိုပါပြstatementနာကြေညာချက်ပုံမှန်မဟုတ်သောသောနှစ် ဦး စလုံး၏ Array ကိုအားလုံး၏ဒြပ်စင်၏စုစုပေါင်းပေါင်းလဒ်ထွက်ရှာရန်မေးတယ်။ ဒီအတွက်ငါတို့သုံးမယ် ဟေး. Hashmap သော့နှင့်တန်ဖိုးများနှင့်အလုပ်လုပ်သည်၊ ၎င်းတွင်သော့များရှိလိမ့်မည်။ ထိုတန်ဖိုးသည်သော့နှင့်ဆက်စပ်နေသည်။ ဒါကြောင့်အတူတူအလုပ်လုပ်တယ်။ ကျွန်ုပ်တို့သည် hashmap ကိုကြေငြာမည်ဖြစ်ပြီးမြေပုံတစ်ခုတည်း၌ပင် Array နှစ်ခုလုံး၏ element များကို ၄ င်းတို့၏ကြိမ်နှုန်းနှင့်အတူမြေပုံထဲသို့သိုလှောင်သွားမည်ဖြစ်သည်။

လည်းကြည့်ရှုပါ
ကျောင်းသားတက်ရောက်မှုမှတ်တမ်းငါ Leetcode ဖြေရှင်းချက်

နမူနာ

ဥပမာတစ်ခုကိုလေ့လာကြည့်ကြစို့။ arrA [] = {1,3,4,5,2}, arrB [] = {2,4,6,7,8}

Array နှစ်ခုစလုံးသည်တူညီသောအရွယ်အစားဖြစ်သောကြောင့်။ Array နှစ်မျိုးလုံးကိုဖြတ်သန်းသွားစဉ်ကျွန်ုပ်တို့သည်တစ်ကြိမ်သာသွားရန်လိုအပ်ပြီး၎င်းတွင် element များနှင့်ကြိမ်နှုန်းများဖြင့်ကျွန်ုပ်တို့ပြီးမြောက်လိမ့်မည်။ ထို့နောက်ကျွန်ုပ်တို့၏မြေပုံတွင်အောက်ပါတန်ဖိုးများရှိလိမ့်မည်။

မြေပုံ: {1: 1, 2: 2, 3: 1, 4: 2, 5: 1, 6: 1, 7: 1, 8: 1} ။

totalSum ဆိုတဲ့ variable ကို 0 ပြီးတဲ့အခါမှာအသုံးများတဲ့ element အားလုံးရဲ့ပေါင်းလဒ်ကိုရဖို့မြေပုံကိုဖြတ်ဖို့လိုတယ်။ ဘယ် element မှာ frequency ရှိသလဲဆိုတာကိုစစ်ဆေးမှာဖြစ်ပါတယ်။ ၁ ဆိုလျှင်အဲ့ဒီ element ကိုရွေးပြီးထို element နှင့် totalSum ကိုပေါင်းပြီး totalSum သို့သိမ်းမည်။

totalSum = 0,

  • မြေပုံ၏ပထမဆုံးဒြပ်စင် '1' တွင်ကြိမ်နှုန်း ၁ ခုရှိပြီး totalSum => totalSum + key = 1 +0 = 1 ထဲသို့ထည့်သည်။
  • မြေပုံ၏ဒုတိယဒြပ်စင် '2' တွင်ကြိမ်နှုန်း ၂ ရှိသည်။ ထို့ကြောင့်၎င်းကီးနှစ်ခုလုံးတွင်တွေ့ရသောကြောင့်ကျွန်ုပ်တို့သည်သော့ကိုယူမည်မဟုတ်ပါ။
  • မြေပုံ၏ပထမဆုံးဒြပ်စင် '3' တွင်ကြိမ်နှုန်း ၁ ခုရှိပြီး totalSum => totalSum + key = 1 +1 = 3 ထဲသို့ထည့်သည်။
  • မြေပုံ၏ဒုတိယဒြပ်စင် '4' တွင်ကြိမ်နှုန်း ၂ ရှိသည်။ ထို့ကြောင့်၎င်းကီးနှစ်ခုလုံးတွင်တွေ့ရသောကြောင့်ကျွန်ုပ်တို့သည်သော့ကိုယူမည်မဟုတ်ပါ။
  • မြေပုံ၏ပထမဆုံးဒြပ်စင် '5' တွင်ကြိမ်နှုန်း ၁ ခုရှိသည်။ ၎င်းကိုကျွန်ုပ်တို့စုစုပေါင်းSum => totalSum + key = 1 +4 = 5 သို့ပေါင်းထည့်သည်။

ထိုနည်းတူစွာကျွန်ုပ်တို့သည်စုစုပေါင်းဆမ်တွင် ၆၊ ၇ နှင့် ၈ ကိုပေါင်းထည့်ရမည်။ အဘယ်ကြောင့်ဆိုသော်အားလုံးသည်ကြိမ်နှုန်းအဖြစ် ၁ ဖြစ်သည်။ ဒါဆို ၁ + ၃ + ၅ + ၆ + ၇ + ၈ = ၃၀ ဖြစ်လာလိမ့်မယ်။

ရလဒ် - ၁၅

ကုဒ်  

နှစ်ခုအစုံ၏ Non- ထပ်ပေါင်းလဒ်သည် 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

နှစ်ခုအစုံ၏ Non- ထပ်ပေါင်းလဒ်အဘို့အ 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” အဆိုပါခင်းကျင်း၏အရှည်ဖြစ်ပါတယ်။ အဘယ်ကြောင့်ဆိုသော်ကျွန်ုပ်တို့သည် hashmap ကိုရှာဖွေခြင်း၊ ဖျက်ခြင်းနှင့်အသစ်ပြုပြင်ခြင်းလုပ်ငန်းများအား O (1) အချိန်ရှုပ်ထွေးမှုတွင်လုပ်ဆောင်နေသောကြောင့်ဖြစ်သည်။ ထို့ကြောင့်ကျွန်ုပ်တို့သည် linear အချိန်ရှုပ်ထွေးအောင်မြင်ရန်နိုင်ခဲ့ကြတယ်။

လည်းကြည့်ရှုပါ
Top K (သို့မဟုတ်အများဆုံးမကြာခဏ) နံပါတ်များကို Stream တစ်ခုတွင်ရှာပါ

အာကာသရှုပ်ထွေးမှု

အို (ဎ) ဘယ်မှာ “ n” အဆိုပါခင်းကျင်း၏အရှည်ဖြစ်ပါတယ်။ Array နှစ်ခုလုံး၏ element များကိုမြေပုံတွင်သိမ်းဆည်းရန်နေရာလွတ်လိုအပ်သည်။