ਮਲਟੀਪਲ ਐਰੇ ਰੇਂਜ ਇੰਕਰੀਮੈਂਟ ਐਕਸ਼ਨ ਤੋਂ ਬਾਅਦ ਸੋਧਿਆ ਐਰੇ ਪ੍ਰਿੰਟ ਕਰੋ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਹਾਰਡ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਇਕਸਪੀਡੀਆ ਫ੍ਰੀਚਾਰਜ ਗੂਗਲ ਅਸਲ ਵਿੱਚ ਮੂਨਫ੍ਰਾਗ ਲੈਬਜ਼ ਓਲਾ ਕੈਬਜ਼ ਗੁਣਾਤਮਕ
ਅਰੇ ਪ੍ਰਸ਼ਨ ਸਮੱਸਿਆ

ਸਮੱਸਿਆ "ਮਲਟੀਪਲ ਐਰੇ ਰੇਂਜ ਇੰਕਰੀਮੈਂਟ ਐਕਸ਼ਨਸ ਦੇ ਬਾਅਦ ਸੋਧਿਆ ਐਰੇ ਪ੍ਰਿੰਟ ਕਰੋ" ਕਹਿੰਦੀ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਇੱਕ ਦਿੱਤਾ ਗਿਆ ਹੈ ਪੂਰਨ ਅੰਕ ਐਰੇ ਅਤੇ 'ਕਿ' 'ਨੰਬਰ ਦੇ ਪ੍ਰਸ਼ਨ ਦਿੱਤੇ ਗਏ ਹਨ. ਇਕ ਪੂਰਨ ਅੰਕ ਵੈਲਯੂ “d” ਵੀ ਦਿੱਤੀ ਗਈ ਹੈ। ਹਰੇਕ ਪ੍ਰਸ਼ਨ ਵਿੱਚ ਦੋ ਪੂਰਨ ਅੰਕ ਹੁੰਦੇ ਹਨ, ਅਰੰਭਕ ਮੁੱਲ ਅਤੇ ਇੱਕ ਅੰਤ ਵਾਲਾ ਮੁੱਲ. ਸਮੱਸਿਆ ਬਿਆਨ 'd' ਦੁਆਰਾ ਦਰਸਾਈ ਗਈ ਰੇਂਜ ਦੇ ਅੰਦਰ ਐਰੇ ਵਿਚਲੇ ਸਾਰੇ ਮੁੱਲ ਵਧਾਉਣ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਕਹਿੰਦਾ ਹੈ. ਸੰਸ਼ੋਧਿਤ ਐਰੇ ਪ੍ਰਿੰਟ ਕਰੋ.

ਉਦਾਹਰਨ

arr[] = {2, 5, 1, 4, 7, 9}
Query: (1, 2), (3, 5), (4, 5), (2, 4), (1, 3)
d = 2
2 9 7 10 13 13

ਕਥਾ

ਇੰਡੈਕਸ (1,2) ਤੋਂ ਵਧਣ ਤੋਂ ਬਾਅਦ ਅਰਰ {2, 7, 3, 4, 7, 9 be ਹੋਵੇਗਾ

ਹੁਣ ਸੂਚਕਾਂਕ ਤੋਂ ਵਾਧਾ (3,5) ਅਰਰ incre 2, 7, 3, 6, 9, 11 become ਬਣ ਜਾਵੇਗਾ

ਇੰਡੈਕਸ ਤੋਂ ਦੁਬਾਰਾ ਵਾਧਾ (4,5) ਅਰਰ {2, 7, 3, 6, 11, 13 be ਹੋਵੇਗਾ

ਹੁਣ ਸੂਚਕਾਂਕ ਤੋਂ ਵਾਧਾ (2,4) ਅਰਰ incre 2, 7, 5, 8, 13, 13 become ਬਣ ਜਾਵੇਗਾ

ਇੰਡੈਕਸ ਤੋਂ ਦੁਬਾਰਾ ਵਾਧਾ (1,3) ਅਰਰ {2, 9, 7, 10, 13, 13 be ਹੋਵੇਗਾ

 

ਮਲਟੀਪਲ ਐਰੇ ਰੇਂਜ ਇੰਕਰੀਮੈਂਟ ਐਕਸ਼ਨ ਤੋਂ ਬਾਅਦ ਸੋਧਿਆ ਐਰੇ ਪ੍ਰਿੰਟ ਕਰੋ

ਮਲਟੀਪਲ ਐਰੇ ਰੇਂਜ ਵਾਧੇ ਕਾਰਜ ਲਈ ਐਲਗੋਰਿਦਮ

  1. ਦਿੱਤੀ ਗਈ ਐਰੇ ਦੇ ਅਕਾਰ ਦੇ ਬਰਾਬਰ ਅਰੇ ਘੋਸ਼ਿਤ ਕਰੋ.
  2. ਐਰੇ ਨੂੰ 0 ਤੋਂ ਕੁਲ ਪੁੱਛ ਕੇ ਪੁੱਛੋ.
  3. ਸਾਨੂੰ ਦਿੱਤੀ ਗਈ ਸੀਮਾ ਵਿੱਚ ਜੋ ਐਰੇ ਬਣਾਇਆ ਹੈ ਉਸ ਵਿੱਚ ਦਿੱਤੇ ਮੁੱਲ ਨੂੰ ਸ਼ਾਮਲ ਕਰੋ. ਜਾਂਚ ਕਰੋ ਕਿ ਦਿੱਤੀ ਗਈ ਪੁੱਛਗਿੱਛ ਦੀ ਅੰਤਲੀ ਰੇਂਜ ਐਰੇ ਦੀ ਲੰਬਾਈ ਤੋਂ ਘੱਟ ਹੈ ਜਾਂ ਨਹੀਂ. ਜੇ ਸਹੀ ਹੈ, ਤਾਂ ਜੋ ਐਰੇ ਬਣਾਇਆ ਹੈ ਉਸ ਤੋਂ ਮੁੱਲ “d” ਘਟਾਓ.
  4. ਦਿੱਤੀ ਗਈ ਐਰੇ ਨੂੰ ਪਾਰ ਕਰੋ ਅਤੇ ਆਉਟਪੁੱਟ ਐਰੇ ਨੂੰ ਮੌਜੂਦਾ ਅਤੇ ਪਿਛਲੇ ਵੈਲਯੂਜ ਅਤੇ ਦਿੱਤੇ ਐਰੇ ਦੇ ਨਾਲ ਅਪਡੇਟ ਕਰੋ.
  5. ਅਪਡੇਟ ਕੀਤੀ ਐਰੇ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰੋ.

ਕਥਾ

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

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

ਹੁਣ, ਅਸੀਂ ਦਿੱਤੀ ਗਈ ਐਰੇ ਦੀ ਪਹਿਲੀ ਪੋਜੀਸ਼ਨ ਨੂੰ ਆਉਟਪੁਟ ਐਰੇ ਦੀ ਪਹਿਲੀ ਪੋਜੀਸ਼ਨ 'ਤੇ ਅਪਡੇਟ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ. ਕਿਉਂਕਿ ਅਸੀਂ ਜੋੜ (ਜਾਂ ਆਉਟਪੁੱਟ) ਐਰੇ ਦੇ ਪਿਛਲੇ ਮੁੱਲ ਅਤੇ ਮੌਜੂਦਾ ਮੁੱਲ ਨੂੰ ਪਾਰ ਕਰ ਰਹੇ ਹਾਂ. ਇਸ ਲਈ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਪਹਿਲੇ ਮੁੱਲ ਨੂੰ ਅਪਡੇਟ ਕੀਤਾ ਹੈ ਅਤੇ ਹੁਣ ਅੰਤ ਤੱਕ ਆਉਟਪੁਟ ਐਰੇ ਦੀ ਪਹਿਲੀ ਸਥਿਤੀ ਤੋਂ ਉਲਟ ਰਿਹਾ ਹਾਂ. ਅਸੀਂ ਪਿਛਲੇ ਅਤੇ ਮੌਜੂਦਾ ਮੁੱਲ ਨੂੰ ਜੋੜਨਗੇ ਅਤੇ ਇਸਨੂੰ ਆਉਟਪੁਟ ਐਰੇ ਵਿੱਚ ਸਟੋਰ ਕਰਾਂਗੇ. ਫਿਰ ਉਸ ਮੁੱਲ ਨੂੰ ਟ੍ਰੈਵਰ ਕਰਦੇ ਸਮੇਂ ਦਿੱਤੇ ਗਏ ਐਰੇ ਦੀਆਂ ਸੰਬੰਧਿਤ ਥਾਵਾਂ ਤੇ ਕਾਪੀ ਕਰੋ. ਸੰਸ਼ੋਧਿਤ ਐਰੇ ਪ੍ਰਿੰਟ ਕਰੋ.

ਕੋਡ

ਮਲਟੀਪਲ ਐਰੇ ਰੇਂਜ ਇੰਕਰੀਮੈਂਟਮੈਂਟ ਆਪ੍ਰੇਸ਼ਨ ਤੋਂ ਬਾਅਦ ਸੋਧੀਆਂ ਐਰੇ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ C ++ ਕੋਡ

#include<iostream>
#include<stdio.h>
#include<string.h>

using namespace std;

struct query
{
    int start, end;
};

void incrementByD(int arr[], struct query q_arr[],int n, int m, int d)
{
    int sum[n];
    memset(sum, 0, sizeof(sum));

    for (int i = 0; i < m; i++)
    {
        sum[q_arr[i].start] += d;

        if ((q_arr[i].end + 1) < n)
            sum[q_arr[i].end + 1] -= d;
    }
    arr[0] += sum[0];
    for (int i = 1; i < n; i++)
    {
        sum[i] += sum[i - 1];
        arr[i] += sum[i];
    }
}

void printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
}

int main()
{
    int arr[] = {2, 5, 1, 4, 7, 9};
    struct query q_arr[] = { { 1, 2 }, { 3, 5 },  {4,5 },
        { 2, 4 }, { 1, 3 }
    };
    int n = sizeof(arr) / sizeof(arr[0]);
    int m = sizeof(q_arr) / sizeof(q_arr[0]);

    int d = 2;

    cout << "Original Array:\n";
    printArray(arr, n);

    incrementByD(arr, q_arr, n, m, d);

    cout << "\nModified Array:\n";
    printArray(arr, n);

    return 0;
}
Original Array:
2 5 1 4 7 9
Modified Array:
2 9 7 10 13 13

ਜਾਵਾ ਕੋਡ ਮਲਟੀਪਲ ਐਰੇ ਰੇਂਜ ਇੰਕਰੀਮੈਂਟ ਐਕਸ਼ਨ ਤੋਂ ਬਾਅਦ ਸੋਧਿਆ ਐਰੇ ਨੂੰ ਪਰਿੰਟ ਕਰਨ ਲਈ

class modifiedArray
{
    static class query
    {
        int start, end;

        query(int start, int end)
        {
            this.start = start;
            this.end = end;
        }
    }

    public static void incrementByD(int[] arr, query[] q_arr, int n, int m, int d)
    {
        int[] sum = new int[n];

        for (int i = 0; i < m; i++)
        {
            sum[q_arr[i].start] += d;

            if ((q_arr[i].end + 1) < n)
                sum[q_arr[i].end + 1] -= d;
        }
        arr[0] += sum[0];
        for (int i = 1; i < n; i++)
        {
            sum[i] += sum[i - 1];
            arr[i] += sum[i];
        }
    }

    public static void printArray(int[] arr, int n)
    {
        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
    }

    public static void main(String[] args)
    {
        int[] arr = { 2, 5, 1, 4, 7, 9};
        query[] q_arr = {new query(1, 2),new query(3,5),new query(4, 5),
                  new query(2, 4),new query(1, 3)
        };

        int n = arr.length;
        int m = q_arr.length;
        int d = 2;
        System.out.println("Original Array:");
        printArray(arr, n);

        incrementByD(arr, q_arr, n, m, d);
        System.out.println("\nModified Array:");
        printArray(arr, n);
    }
}
Original Array:
2 5 1 4 7 9
Modified Array:
2 9 7 10 13 13

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

ਟਾਈਮ ਜਟਿਲਤਾ

 ਓ (ਕਿ + + ਐਨ) ਜਿੱਥੇ ਕਿ “ਐਨ” ਐਰੇ ਵਿਚਲੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਹੈ ਅਤੇq ” ਪੁੱਛਗਿੱਛ ਦੀ ਗਿਣਤੀ ਹੈ. ਕਿਉਂਕਿ ਅਸੀਂ ਇੱਕ ਅਗੇਤਰ ਦੀ ਤਰ੍ਹਾਂ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ, ਇਸ ਲਈ ਸਾਡੇ ਕੋਲ ਲੰਬੇ ਸਮੇਂ ਦੀ ਜਟਿਲਤਾ ਹੈ.

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

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