element တစ်ခု၏ပထမဆုံးနှင့်နောက်ဆုံးအညွှန်းများအကြားအများဆုံးကွာခြားချက်


ခက်ခဲအဆင့် အလယ်အလတ်
မကြာခဏမေးတယ် တိကျသော အမေဇုံ ခရီးသွား ကွမ်းခြံကုန်း အိုလာ Cabs SAP ဓာတ်ခွဲခန်း
အခင်းအကျင်း hash

မင်းမှာတစ်ခုရှိတယ်ဆိုပါစို့ အခင်းအကျင်း of ကိန်း။ ပြarrayနာက“ array အတွင်းရှိ element တစ်ခု၏ပထမနှင့်နောက်ဆုံးအညွှန်းကိန်းများအကြားအများဆုံးကွာခြားချက်” သည်ခင်းကျင်းချက်အတွင်းရှိအရေအတွက်တစ်ခုချင်းစီ၏ပထမနှင့်နောက်ဆုံးအညွှန်းကိန်းများအကြားခြားနားချက်ကိုရှာဖွေရန်တောင်းဆိုသည်။

နမူနာ

arr[] =  {2, 3, 5, 1, 4, 6, 2, 5};
6

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

2 ရဲ့ပထမ ဦး ဆုံးအညွှန်းကိန်း→ 0

2 ရဲ့နောက်ဆုံးအညွှန်းကိန်း→ 6

အများဆုံးခြားနားချက် (6-0) = 6

element တစ်ခု၏ပထမဆုံးနှင့်နောက်ဆုံးအညွှန်းများအကြားအများဆုံးကွာခြားချက်

arr[] =  {2, 3, 6, 5, 4, 5, 1, 4};
3

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

4 ရဲ့ပထမ ဦး ဆုံးအညွှန်းကိန်း→ 4

4 ရဲ့နောက်ဆုံးအညွှန်းကိန်း→ 7

အများဆုံးခြားနားချက် (7-4) = 3

algorithm

  1. မြေတပြင်လုံးကိုဖြတ်သန်း အခင်းအကျင်း.
  2. Array တစ်ခုချင်းစီကိုရွေးချယ်ပြီးပထမဆုံးနှင့်နောက်ဆုံး element ကိုယူပြီး HashTable တွင်သိမ်းထားပါ။
  3. ဖြတ်သန်း မြေပုံ:
    1. element တစ်ခုစီ၏ပထမနှင့်နောက်ဆုံးအညွှန်းကိန်းများအကြားခြားနားချက်ကိုရှာဖွေပါ။
    2. အမြင့်ဆုံးကွာခြားချက်ကိုအချို့သော variable တစ်ခုထဲသို့သိုလှောင်ထားပြီးသင်ယခင်တန်ဖိုးထက်အများဆုံးတန်ဖိုးကိုရှာသည့်အခါတိုင်းမွမ်းမံပါ။
  4. အများဆုံးခြားနားချက်ကိုပြန်သွားပါ။

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

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

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

ဥပမာတစ်ခုကိုသုံးသပ်ကြည့်ကြစို့။

နမူနာ

ဆိုက်ရောက် [] = {2, 3, 5, 1, 4, 6, 2, 5}

ကျနော်တို့ခင်းကျင်း input ကိုရှိသည်။ ဒီဟာကိုဖြေရှင်းဖို့အတွက်ငါတို့က class ကိုသုံးမယ်။ ၎င်းသည်ပထမ ဦး ဆုံးအကြိမ်ဖြတ်သန်းသွားပါကကျွန်ုပ်တို့သည်ဒြပ်စင်တိုင်းကိုရှာဖွေလိမ့်မည်။ ပြီးရင်ကျွန်တော်တို့ကသူ့ရဲ့ index ကိုပထမဆုံး index အဖြစ်ထားလိမ့်မယ်။ ပြီးရင်ငါတို့ index ကိုဒုတိယအညွှန်းအဖြစ်ထားမယ်။ ဤနည်းလမ်းကို အသုံးပြု၍ မြေပုံရှိသည် -

မြေပုံ: ၁-၃ ၃: တရားမဝင်သော

2-> 0: 6,

3-> ၁ null

4-> 4: တရားမဝင်သော

5-> 2: 7,

6-> 5: တရားမဝင်သော

ကျနော်တို့မြေပုံကိုဖြတ်ကျော်သွားမှာပါ။ တန်ဖိုးတစ်ခုစီကိုယူပြီးသူတို့ရဲ့ညွှန်းကိန်းတွေရဲ့ကွဲပြားခြားနားမှုကိုစစ်ဆေးပါလိမ့်မယ်။ null တန်ဖိုးများရှိသည့်တန်ဖိုးများအားလုံးကိုကျွန်ုပ်တို့လျစ်လျူရှုထားမည်။ ဒီတော့ကျွန်တော်တို့မှာ ၂ နဲ့ ၅ ရှိတယ် 2 ထက်၎င်း၏ပထမ ဦး ဆုံးနှင့်နောက်ဆုံးအညွှန်းကိန်းအကြားအများဆုံးခြားနားချက် (6) ရှိပါတယ် 5 အရာတစ် ဦး ခြားနားချက် (5) ရှိပါတယ်။ ဒါဆိုငါတို့ ၆ ကိုအမြင့်ဆုံးကွာခြားချက်အဖြစ်ပြန်ပို့မယ်။ အဲဒါကငါတို့ရဲ့အဖြေပဲ။

array ထဲတွင် element တစ်ခု၏ပထမနှင့်နောက်ဆုံးအညွှန်းများအကြားအများဆုံးခြားနားချက်ကိုရှာဖွေရန် C ++ ကုဒ်

#include<bits/stdc++.h>

using namespace std;

int maxDifference(int arr[], int n)
{
    struct IndexValue
    {
        int fir, last;
    };
    unordered_map<int, IndexValue> MAP;
    for (int i=0; i<n; i++)
    {
        if (MAP.find(arr[i]) == MAP.end())
            MAP[arr[i]].fir = i;

        MAP[arr[i]].last = i;
    }

    int difference, differenceIndex = INT_MIN;

    unordered_map<int, IndexValue>::iterator itr;
    for (itr=MAP.begin(); itr != MAP.end(); itr++)
    {
        difference = (itr->second).last - (itr->second).fir;
        if (differenceIndex < difference)
            differenceIndex = difference;
    }
    return differenceIndex;
}
int main()
{
    int arr[] = {2, 3, 5, 1, 4, 6, 2, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "Maximum difference b/w the first and last index of a number= "<<maxDifference(arr, n);
    return 0;
}
Maximum difference b/w the first and last index of a number= 6

element တစ်ခု၏ပထမနှင့်နောက်ဆုံးအညွှန်းများအကြားအများဆုံးကွာခြားမှုကိုရှာဖွေရန် Java ကုဒ်ဖြစ်သည်

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

class IndexValue
{
    int first;
    int second;
    public IndexValue()
    {
        super();
    }
}
class DifferenceOfIndexes
{
    private static int getIndexesDifferent(int[] arr)
    {
        int n = arr.length;
        int differenceIndex = 0;
        Map<Integer, IndexValue> MAP = new HashMap<Integer, IndexValue>();

        for (int i = 0; i < n; i++)
        {
            if (MAP.containsKey(arr[i]))
            {
                IndexValue iv = MAP.get(arr[i]);
                iv.second = i;
            }
            else
            {
                IndexValue iv = new IndexValue();
                iv.first = i;
                MAP.put(arr[i], iv);
            }
        }
        for (Map.Entry<Integer, IndexValue> entry : MAP.entrySet())
        {
            IndexValue iv = entry.getValue();
            if ((iv.second - iv.first) > differenceIndex)
            {
                differenceIndex = iv.second - iv.first;
            }
        }
        return differenceIndex;
    }
    public static void main(String[] args)
    {
        int arr[]= {2,3,5,1,4,6,2,5};
        System.out.println("Maximum difference b/w the first and last index of a number= "+ getIndexesDifferent(arr));
    }
}
Maximum difference b/w the first and last index of a number= 6

ရှုပ်ထွေးဆန်းစစ်ခြင်း

အချိန်ရှုပ်ထွေး

အို (ဎ) ဘယ်မှာ “ n ' သည် array အတွင်းရှိ element အရေအတွက်ဖြစ်သည်

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

အို (ဎ) ဘယ်မှာ “ n ' သည် array အတွင်းရှိ element အရေအတွက်ဖြစ်သည်