ਐਰੇ ਵਿਚਲੇ ਇਕ ਐਲੀਮੈਂਟ ਦੇ ਪਹਿਲੇ ਅਤੇ ਆਖਰੀ ਇੰਡੈਕਸ ਵਿਚ ਅਧਿਕਤਮ ਅੰਤਰ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਦਰਮਿਆਨੇ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਇਕੱਤਰ ਐਮਾਜ਼ਾਨ ਵਾਧੇ MakeMyTrip ਓਲਾ ਕੈਬਜ਼ SAP ਲੈਬਜ਼
ਅਰੇ ਹੈਸ਼

ਮੰਨ ਲਓ, ਤੁਹਾਡੇ ਕੋਲ ਇਕ ਹੈ ਐਰੇ of ਪੂਰਨ ਅੰਕ. ਸਮੱਸਿਆ "ਐਰੇ ਵਿਚਲੇ ਇਕ ਐਲੀਮੈਂਟ ਦੇ ਪਹਿਲੇ ਅਤੇ ਆਖਰੀ ਇੰਡੈਕਸ ਵਿਚ ਅਧਿਕਤਮ ਅੰਤਰ" ਇਕ ਐਰੇ ਵਿਚ ਮੌਜੂਦ ਹਰੇਕ ਨੰਬਰ ਦੇ ਪਹਿਲੇ ਅਤੇ ਆਖਰੀ ਇੰਡੈਕਸ ਵਿਚ ਅੰਤਰ ਲੱਭਣ ਲਈ ਪੁੱਛਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਫਰਕ ਸਭ ਤੋਂ ਵੱਧ ਰਿਹਾ ਹੈ.

ਉਦਾਹਰਨ

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

ਕਥਾ

2 ਦਾ ਪਹਿਲਾ ਇੰਡੈਕਸ → 0

2 ਦਾ ਆਖਰੀ ਇੰਡੈਕਸ → 6

ਅਧਿਕਤਮ ਅੰਤਰ (6-0) = 6

ਐਰੇ ਵਿਚਲੇ ਇਕ ਐਲੀਮੈਂਟ ਦੇ ਪਹਿਲੇ ਅਤੇ ਆਖਰੀ ਇੰਡੈਕਸ ਵਿਚ ਅਧਿਕਤਮ ਅੰਤਰ

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

ਕਥਾ

4 ਦਾ ਪਹਿਲਾ ਇੰਡੈਕਸ → 4

4 ਦਾ ਆਖਰੀ ਇੰਡੈਕਸ → 7

ਅਧਿਕਤਮ ਅੰਤਰ (7-4) = 3

ਐਲਗੋਰਿਥਮ

  1. ਸਾਰਾ ਟ੍ਰਾਵਰ ਕਰੋ ਐਰੇ.
  2. ਇੱਕ ਐਰੇ ਦੇ ਹਰ ਤੱਤ ਨੂੰ ਚੁਣੋ ਅਤੇ ਇਸਦਾ ਪਹਿਲਾ ਅਤੇ ਆਖਰੀ ਤੱਤ ਪ੍ਰਾਪਤ ਕਰੋ ਅਤੇ ਇਸ ਨੂੰ ਹੈਸ਼ ਟੇਬਲ ਵਿੱਚ ਸਟੋਰ ਕਰੋ.
  3. ਪਾਰ ਕਰੋ ਫੋਲਡਰ ਨੂੰ:
    1. ਹਰੇਕ ਤੱਤ ਦੇ ਪਹਿਲੇ ਅਤੇ ਆਖਰੀ ਤਤਕਰਾ ਵਿਚਕਾਰ ਅੰਤਰ ਲੱਭੋ.
    2. ਵੱਧ ਫਰਕ ਨੂੰ ਕੁਝ ਵੇਰੀਏਬਲ ਵਿੱਚ ਸਟੋਰ ਕਰੋ ਅਤੇ ਜਦੋਂ ਵੀ ਤੁਹਾਨੂੰ ਪਿਛਲੇ ਮੁੱਲ ਨਾਲੋਂ ਵੱਧ ਮੁੱਲ ਮਿਲੇ ਤਾਂ ਇਸ ਨੂੰ ਅਪਡੇਟ ਕਰਦੇ ਰਹੋ.
  4. ਵੱਧ ਤੋਂ ਵੱਧ ਅੰਤਰ ਵਾਪਸ ਕਰੋ.

ਕਥਾ

ਸਾਨੂੰ ਇੱਕ ਦਿੱਤਾ ਗਿਆ ਹੈ ਪੂਰਨ ਅੰਕ ਐਰੇ, ਸਾਨੂੰ ਐਰੇ ਦੇ ਹਰੇਕ ਮੁੱਲ ਦੇ ਪਹਿਲੇ ਇੰਡੈਕਸ ਅਤੇ ਆਖਰੀ ਇੰਡੈਕਸ ਵਿਚ ਅੰਤਰ ਲੱਭਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ. ਇਸਦੇ ਪਹਿਲੇ ਅਤੇ ਆਖਰੀ ਇੰਡੈਕਸ ਦੇ ਵਿਚਕਾਰ ਕਿਸੇ ਵੀ ਗਿਣਤੀ ਲਈ ਵੱਧ ਤੋਂ ਵੱਧ ਅੰਤਰ ਦਾ ਪਤਾ ਲਗਾਓ. ਇਸਦੇ ਲਈ, ਅਸੀਂ ਇਸਤੇਮਾਲ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ ਹੈਸ਼ਿੰਗ. ਅਸੀਂ ਇੱਕ ਐਰੇ ਐਲੀਮੈਂਟ ਲਵਾਂਗੇ ਅਤੇ ਇਸਦੇ ਪਹਿਲੇ ਇੰਡੈਕਸ ਅਤੇ ਆਖਰੀ ਇੰਡੈਕਸ ਨੂੰ ਲੱਭਾਂਗੇ ਜਾਂ ਜਦੋਂ ਇਹ ਪਹਿਲੀ ਅਤੇ ਆਖਰੀ ਵਾਪਰਦਾ ਹੈ.

ਸਾਰੇ ਤੱਤ ਅਤੇ ਉਨ੍ਹਾਂ ਦੇ ਪਹਿਲੇ ਅਤੇ ਆਖਰੀ ਇੰਡੈਕਸ ਨੂੰ ਨਕਸ਼ੇ ਵਿੱਚ ਪਾਉਣ ਤੋਂ ਬਾਅਦ ਨਕਸ਼ੇ ਨੂੰ ਪਾਰ ਕਰੋ. ਹੁਣ ਹਰੇਕ ਤੱਤ ਨੂੰ ਚੁਣੋ ਅਤੇ ਫਿਰ ਉਨ੍ਹਾਂ ਦਾ ਪਹਿਲਾ ਅਤੇ ਆਖਰੀ ਸੂਚਕਾਂਕ ਲਓ ਅਤੇ ਅੰਤਰ ਨੂੰ ਪਤਾ ਲਗਾਓਗੇ ਕਿ ਇਹ ਸਭ ਤੋਂ ਵੱਧ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ. ਅਸੀਂ ਇੱਕ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ ਅਧਿਕਤਮ ਵੱਧ ਅੰਤਰ ਤੇ ਨਜ਼ਰ ਰੱਖਣ ਲਈ. ਅਸੀਂ ਹਰ ਇੱਕ ਤੱਤ ਦਾ ਪਹਿਲਾ ਅਤੇ ਆਖਰੀ ਸੂਚਕਾਂਕ ਸਟੋਰ ਕਰਨ ਲਈ ਇੱਕ ਕਲਾਸ ਅਤੇ ਇਸਦੇ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ.

ਆਓ ਇੱਕ ਉਦਾਹਰਣ ਤੇ ਵਿਚਾਰ ਕਰੀਏ:

ਉਦਾਹਰਨ

ਅਰੁ [] = {2, 3, 5, 1, 4, 6, 2, 5

ਸਾਡੇ ਕੋਲ ਇੱਕ ਐਰੇ ਇਨਪੁਟ ਹੈ. ਇਸ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਅਸੀਂ ਇਕ ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ. ਅਸੀਂ ਹਰ ਤੱਤ ਦੀ ਭਾਲ ਕਰਾਂਗੇ ਜੇ ਇਹ ਪਹਿਲੀ ਵਾਰ ਉਲਝਾਇਆ ਜਾ ਰਿਹਾ ਹੈ. ਫਿਰ ਅਸੀਂ ਇਸਦੇ ਸੂਚਕਾਂਕ ਨੂੰ ਪਹਿਲੇ ਇੰਡੈਕਸ ਦੇ ਤੌਰ ਤੇ ਸਟੋਰ ਕਰਾਂਗੇ ਅਤੇ ਜਦੋਂ ਉਹੀ ਤੱਤ ਮੁੜ ਆਵੇਗਾ. ਫਿਰ ਹਰ ਵਾਰ ਅਸੀਂ ਇਸਦੇ ਸੂਚਕਾਂਕ ਨੂੰ ਦੂਜਾ ਸੂਚਕਾਂਕ ਦੇ ਰੂਪ ਵਿੱਚ ਸਟੋਰ ਕਰਾਂਗੇ. ਇਸ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦਿਆਂ, ਸਾਡੇ ਕੋਲ ਇੱਕ ਨਕਸ਼ਾ ਹੈ:

ਨਕਸ਼ਾ: 1-> 3: ਖਾਲੀ,

2-> 0: 6,

3-> 1, ਨਲ,

4-> 4: ਨਲ,

5-> 2: 7,

6-> 5: ਖਾਲੀ

ਅਸੀਂ ਨਕਸ਼ੇ ਤੋਂ ਪਾਰ ਲੰਘਾਂਗੇ, ਅਤੇ ਅਸੀਂ ਹਰ ਮੁੱਲ ਲਵਾਂਗੇ ਅਤੇ ਉਨ੍ਹਾਂ ਦੇ ਸੂਚਕਾਂਕਾਂ ਦੇ ਅੰਤਰ ਨੂੰ ਵੇਖਾਂਗੇ. ਅਸੀਂ ਉਨ੍ਹਾਂ ਸਾਰੀਆਂ ਕਦਰਾਂ ਕੀਮਤਾਂ ਨੂੰ ਨਜ਼ਰ ਅੰਦਾਜ਼ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ ਜਿਨ੍ਹਾਂ ਦੇ ਸ਼ੁੱਧ ਮੁੱਲ ਹਨ. ਇਸ ਲਈ ਸਾਡੇ ਕੋਲ 2 ਅਤੇ 5 ਹਨ ਅਤੇ ਜਿਸ ਵਿਚੋਂ 2 ਇਸਦੇ ਪਹਿਲੇ ਅਤੇ ਆਖਰੀ ਇੰਡੈਕਸ ਨਾਲੋਂ ਵੱਧ ਅੰਤਰ (6) ਹੈ 5 ਜਿਸ ਵਿੱਚ ਅੰਤਰ ਹੈ (5). ਇਸ ਲਈ ਅਸੀਂ 6 ਨੂੰ ਵੱਧ ਤੋਂ ਵੱਧ ਅੰਤਰ ਵਜੋਂ ਵਾਪਸ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ ਅਤੇ ਇਹ ਸਾਡਾ ਜਵਾਬ ਹੋਵੇਗਾ.

ਐਰੇ ਵਿਚਲੇ ਇਕ ਐਲੀਮੈਂਟ ਦੇ ਪਹਿਲੇ ਅਤੇ ਆਖਰੀ ਇੰਡੈਕਸ ਵਿਚ ਵੱਧ ਤੋਂ ਵੱਧ ਅੰਤਰ ਲੱਭਣ ਲਈ ਸੀ ++ ਕੋਡ

#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

ਐਰੇ ਵਿਚਲੇ ਇਕ ਐਲੀਮੈਂਟ ਦੇ ਪਹਿਲੇ ਅਤੇ ਆਖਰੀ ਇੰਡੈਕਸ ਵਿਚ ਅਧਿਕਤਮ ਅੰਤਰ ਲੱਭਣ ਲਈ ਜਾਵਾ ਕੋਡ

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) ਜਿੱਥੇ ਕਿ “ਐਨ” ਐਰੇ ਵਿਚਲੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਹੈ

ਸਪੇਸ ਦੀ ਜਟਿਲਤਾ

ਹੇ (n) ਜਿੱਥੇ ਕਿ “ਐਨ” ਐਰੇ ਵਿਚਲੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਹੈ