ਐਰੇ ਨੂੰ ਘਟਾਏ ਰੂਪ ਵਿੱਚ ਬਦਲੋ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਦਰਮਿਆਨੇ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਸਬੰਧਤ Snapchat ਜ਼ੋਮ ਯਾਹੂ
ਅਰੇ ਹੈਸ਼ ਲੜੀਬੱਧ

ਸਮੱਸਿਆ ਦਾ ਬਿਆਨ

ਸਮੱਸਿਆ ਨੂੰ "ਇੱਕ ਐਰੇ ਨੂੰ ਘਟਾਏ ਹੋਏ ਰੂਪ ਵਿੱਚ ਬਦਲੋ" ਕਹਿੰਦਾ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਅਕਾਰ ਦੇ ਵੱਖਰੇ ਤੱਤਾਂ ਦੇ ਪੂਰਨ ਅੰਕ ਦੀ ਇੱਕ ਐਰੇ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ. ਸਮੱਸਿਆ ਬਿਆਨ ਨੂੰ ਐਰੇ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਘਟਾਉਣ ਲਈ ਕਿਹਾ ਗਿਆ ਹੈ ਕਿ ਨਵੇਂ ਨੰਬਰ ਐਰੇ ਵਿਚ 0 ਤੋਂ n-1 ਦੇ ਅੰਦਰ ਰੱਖੇ ਜਾਣ. ਐਰੇ ਦੀ ਸਭ ਤੋਂ ਛੋਟੀ ਜਿਹੀ ਗਿਣਤੀ ਨੂੰ 0 ਦੇ ਤੌਰ ਤੇ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਜੋ ਕਿ 1 ਤੋਂ ਵੱਡਾ ਹੈ. ਅਤੇ ਨਿਰੰਤਰ n-1 ਨੰਬਰ ਐਰੇ ਦਾ ਸਭ ਤੋਂ ਵੱਡਾ ਤੱਤ ਹੈ.

ਉਦਾਹਰਨ

arr[]={20,10,35,42,8}
2 1 3 4 0

ਵਿਆਖਿਆ: ਸਾਨੂੰ ਐਰੇ ਨੰਬਰ ਨੂੰ 0 ਦੇ ਅੰਦਰ ਘਟਾਏ ਹੋਏ ਰੂਪ ਵਿਚ ਐਨ -1 ਸੀਮਾ ਦੇ ਅੰਦਰ ਰੱਖਣਾ ਹੈ. ਅਸੀਂ ਵੇਖ ਸਕਦੇ ਹਾਂ ਕਿ 8 ਸਭ ਤੋਂ ਛੋਟਾ ਹੈ, ਇਸ ਲਈ ਇਹ 0 ਹੈ. 10 ਅਗਲਾ ਹੈ ਇਸ ਲਈ ਇਹ 1, 20 ਹੈ 2 ਅਤੇ ਇਸ ਤਰਾਂ ਹੈ.

 

ਐਰੇਗੋਰਿਦਮ ਨੂੰ ਇੱਕ ਐਰੇ ਨੂੰ ਘਟਾਏ ਰੂਪ ਵਿੱਚ ਬਦਲਣ ਲਈ

1. Declare a temporary array of size the same as the original array.
2. Copy all the values of the given array into the declared array.
3. Sort that array in which we have copied the value of the original array.
4. Declare a map and set an integer variable ‘val’ to 0.
5. Traverse the array and store the value of the temp array’ element as a key into the map and a val value and increasing the count of ‘val’ by 1 every time.
6. Traverse the original array from 0 to n-1.
  1. Place the value of the map’s key into the array.
7. Print the original array in which we replace the value of the map.

ਕਥਾ

ਅਸੀਂ ਪੂਰਨ ਅੰਕ ਦੀ ਇੱਕ ਐਰੇ ਦਿੱਤੀ ਹੈ, ਸਾਨੂੰ ਐਰੇ ਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ ਘਟਾਉਣਾ ਪਏਗਾ ਕਿ ਅਸਲ ਐਰੇ ਵਿਚ ਹਰੇਕ ਨੰਬਰ ਰੇਂਜ ਤੋਂ ਕੋਈ ਮੁੱਲ ਗੁੰਮਣ ਤੋਂ ਬਿਨਾਂ ਸੀਮਾ 0 ਤੋਂ n-1 ਵਿਚ ਲੈ ਲਵੇਗੀ. ਇਸਦਾ ਅਰਥ ਇਹ ਹੈ ਕਿ ਜੇ ਅਸੀਂ ਐਰੇ ਵਿਚ 5 ਨੰਬਰ ਦਿੱਤੇ ਹਨ ਤਾਂ ਅਸੀਂ 0 ਤੋਂ 4 ਤੱਕ ਨੰਬਰ ਨੂੰ ਮੂਲ ਐਰੇ ਦੇ ਇਕ ਐਲੀਮੈਂਟ ਦੀ ਹਰੇਕ ਸਥਿਤੀ ਵਿਚ ਰੱਖਾਂਗੇ.

ਇਸਦੇ ਲਈ, ਅਕਾਰ n ਦੀ ਇੱਕ ਅਤਿਰਿਕਤ ਐਰੇ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ, ਅਸੀ ਕੀ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ ਅਸੀ ਅਸਲ ਐਰੇ ਨੂੰ ਓਰਿਅਲ ਐਰੇ ਤੋਂ ਕਾਪੀ ਕਰਾਂਗੇ. ਕਿਉਂਕਿ ਅਸੀਂ ਇਸ 'ਤੇ ਆਪ੍ਰੇਸ਼ਨ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ. ਅਸੀਂ ਕਾਪੀ ਕੀਤੀ ਐਰੇ ਨੂੰ ਘੱਟ ਰਹੇ ਕ੍ਰਮ ਵਿੱਚ ਕ੍ਰਮਬੱਧ ਕਰਾਂਗੇ. ਕਿਉਂਕਿ ਸਾਨੂੰ ਹਰੇਕ ਤੱਤ ਨੂੰ ਇੱਕ ਗਿਣਤੀ ਵਿੱਚ ਘਟਾਉਣਾ ਹੈ ਜੋ ਦਿੱਤੀ ਗਈ ਸੀਮਾ ਤੋਂ suitableੁਕਵਾਂ ਹੈ. ਅਸੀਂ ਇੱਕ ਨਕਸ਼ਾ ਅਤੇ ਇੱਕ ਪਰਿਵਰਤਨਸ਼ੀਲ ਘੋਸ਼ਿਤ ਕਰਾਂਗੇ 'ਵੈਲ' 0 ਤੱਕ

ਨਕਸ਼ਾ ਅਸਥਾਈ ਐਰੇ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਸੰਭਾਲਣ ਜਾ ਰਿਹਾ ਹੈ ਜਿਸ ਨੂੰ ਅਸੀਂ ਇੱਕ ਕੁੰਜੀ ਦੇ ਰੂਪ ਵਿੱਚ ਬਣਾਇਆ ਹੈ ਅਤੇ ਇਹ ਵੀ ਹੁਣ ਅਸਥਾਈ ਐਰੇ ਨੂੰ ਕ੍ਰਮਬੱਧ ਕੀਤਾ ਗਿਆ ਹੈ ਤਾਂ ਜੋ ਅਸੀਂ ਓ ਤੋਂ n-1 ਤੱਕ ਨੰਬਰ ਰੱਖ ਸਕੀਏ. ਅਸੀਂ ਐਰੇ ਨੂੰ ਪਾਰ ਕਰਾਂਗੇ ਅਤੇ ਐਲੀਮੈਂਟਸ ਨੂੰ ਕੁੰਜੀ ਅਤੇ ਦੇ ਤੌਰ ਤੇ ਰੱਖਾਂਗੇ Val ਕੁੰਜੀ ਦੇ ਮੁੱਲ ਨੂੰ. ਦਾ ਮੁੱਲ Val ਜਦੋਂ ਵੀ ਅਸੀਂ ਕਿਸੇ ਨਵੇਂ ਮੁੱਲ ਦੇ ਨਾਲ ਲੰਘਦੇ ਹਾਂ ਤਾਂ ਅਸੀਂ 1 ਨਾਲ ਵਧਦੇ ਜਾਵਾਂਗੇ, ਇਸਲਈ ਇਹ ਆਪਣੇ ਆਪ 0 ਤੋਂ n-1 ਤੱਕ ਹੁੰਦਾ ਹੈ.

ਅਸਲ ਐਰੇ ਨੂੰ ਪਾਰ ਕਰੋ ਅਤੇ ਨਕਸ਼ੇ ਦੇ ਸਾਰੇ ਮੁੱਲਾਂ ਨੂੰ ਅਸਲ ਐਰੇ ਵਿਚ ਸ਼ਾਮਲ ਕਰੋ ਜਾਂ ਅਸੀਂ ਕਹਿ ਸਕਦੇ ਹਾਂ ਕਿ ਅਸੀਂ ਅਸਲੀ ਐਰੇ ਨੂੰ ਇਨ੍ਹਾਂ ਨਵੇਂ ਮੁੱਲਾਂ ਨਾਲ ਬਦਲ ਦੇਵਾਂਗੇ. ਅਸਲ ਐਰੇ ਦੇ ਉਹ ਤੱਤ ਪ੍ਰਿੰਟ ਕਰੋ ਕਿਉਂਕਿ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਇਸ ਨੂੰ ਸੀਮਾ 0 ਦੇ ਰੂਪ ਵਿੱਚ ਘਟਾ ਕੇ ਐਨ -1 ਕਰ ਦਿੱਤਾ ਹੈ.

ਐਰੇ ਨੂੰ ਘਟਾਏ ਰੂਪ ਵਿੱਚ ਬਦਲੋ

ਕੋਡ

ਐਰੇ ਨੂੰ ਘਟਾਏ ਰੂਪ ਵਿੱਚ ਬਦਲਣ ਲਈ ਸੀ ++ ਕੋਡ

#include<iostream>
#include<unordered_map>
#include<algorithm>

using namespace std;

void convert(int arr[], int n)
{
    int temp[n];
    memcpy(temp, arr, n*sizeof(int));

    sort(temp, temp + n);

    unordered_map<int, int> umap;

    int val = 0;
    for (int i = 0; i < n; i++)
        umap[temp[i]] = val++;

    for (int i = 0; i < n; i++)
        arr[i] = umap[arr[i]];
}
void printArr(int arr[], int n)
{
    for (int i=0; i<n; i++)
        cout << arr[i] << " ";
}
int main()
{
    int arr[] = {20,10,35,42,8};
    int n = sizeof(arr)/sizeof(arr[0]);

    convert(arr, n);
    cout << "Converted Array is : \n";
    printArr(arr, n);
    return 0;
}
Converted Array is :
2 1 3 4 0

 

ਐਰੇ ਨੂੰ ਘਟੇ ਹੋਏ ਰੂਪ ਵਿੱਚ ਬਦਲਣ ਲਈ ਜਾਵਾ ਕੋਡ

import java.util.HashMap;
import java.util.Arrays;

class ReducedArray
{
    public static void convert(int arr[], int n)
    {
        int temp[] = arr.clone();

        Arrays.sort(temp);

        HashMap<Integer, Integer> umap = new HashMap<>();

        int val = 0;
        for (int i = 0; i < n; i++)
            umap.put(temp[i], val++);


        System.out.println("Converted Array is : ");
        for (int i = 0; i < n; i++)
        {
            arr[i] = umap.get(arr[i]);
            System.out.print(arr[i] + " ");
        }
    }
    public static void main(String[] args)
    {

        int arr[] = {20,10,35,42,8};
        int n = arr.length;
        convert(arr, n);

    }
}
Converted Array is :
2 1 3 4 0

 

ਜਟਿਲਤਾ ਵਿਸ਼ਲੇਸ਼ਣ

ਟਾਈਮ ਜਟਿਲਤਾ

We ਕ੍ਰਮਬੱਧ ਸਾਡੀ ਇਨਪੁਟ ਐਰੇ. ਇਸ ਕਰਕੇ O (n ਲਾਗ n) ਜਿੱਥੇ ਕਿ “ਐਨ” ਐਰੇ ਦਾ ਆਕਾਰ ਹੈ.

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

ਕਿਉਂਕਿ ਅਸੀਂ ਇਨਪੁਟ ਐਰੇ ਨੂੰ ਸਟੋਰ ਕੀਤਾ ਹੈ, ਅਸੀਂ ਪ੍ਰਾਪਤ ਕੀਤਾ ਹੇ (n) ਜਿੱਥੇ ਕਿ “ਐਨ” ਐਰੇ ਦਾ ਆਕਾਰ ਹੈ.