דרוק מאַדאַפייד מענגע נאָך קייפל מענגע קייט ינקראַמאַנט אַפּעריישאַנז


שוועריקייט לעוועל שווער
אָפט געבעטן אין עקספּעדיאַ פרעעטשאַרגע גוגל טאקע מאָנפראָג לאַבס אָלאַ קאַבס Qualtrics
מענגע אָנפֿרעג פּראָבלעם

די פּראָבלעם "פּרינטעד מאַדאַפייד מענגע נאָך קייפל מענגע קייט ינקראַמאַנט אַפּעריישאַנז" שטאַטן אַז איר זענען געגעבן אַן ינטעגער מענגע און 'q' נומערן פון פֿראגן זענען געגעבן. איין גאַנץ נומער "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}

איצט ינקראַמאַנט פון אינדעקס (3,5) אַרר וועט ווערן {2, 7, 3, 6, 9, 11}

ווידער פאַרגרעסערן פון אינדעקס (4,5) אַרר וועט זיין {2, 7, 3, 6, 11, 13}

איצט ינקראַמאַנט פון אינדעקס (2,4) אַרר וועט ווערן {2, 7, 5, 8, 13, 13}

ווידער פאַרגרעסערן פון אינדעקס (1,3) אַרר וועט זיין {2, 9, 7, 10, 13, 13}

 

דרוק מאַדאַפייד מענגע נאָך קייפל מענגע קייט ינקראַמאַנט אַפּעריישאַנז

אַלגערידאַם פֿאַר קייפל מענגע ינקראַמאַנט אַפּעריישאַנז

  1. דערקלערן אַ מענגע ווי די זעלבע גרייס ווי די געגעבן מענגע.
  2. אַריבער די מענגע פון ​​0 צו די גאַנץ נומער פון פֿראגן.
  3. לייג די געגעבן ווערט אין די מענגע מיר באשאפן צו די געגעבן קייט. קאָנטראָלירן אויב די סאָף קייט פון די געגעבן אָנפֿרעג איז ווייניקער ווי די לענג פון די מענגע. אויב אמת, פאַרמינערן די ווערט “d” פון די מענגע מיר באשאפן.
  4. אַריבער די געגעבן מענגע און דערהייַנטיקן די רעזולטאַט מענגע מיט די אַדישאַן פון די קראַנט און די פריערדיקע וואַלועס און די געגעבן מענגע.
  5. דרוק דעם דערהייַנטיקט מענגע.

דערקלערונג

געגעבן אַן מענגע of ינטעגער און עטלעכע נומער פון קוויריז, יעדער אָנפֿרעג כּולל די סטאַרטינג און סאָף קייט און אַ געגעבן ווערט. מיר מוזן לייגן אַרויף די געגעבן ווערט צו אַלע נומערן פֿון די אָנהייב פונט צו די סאָף פונט פון די געגעבן קייט. מיר וועלן מאַכן אַ פּלאַץ פון פֿראגן. צוויי פון די נומער וועט זיין פארבונדן מיט יעדער פון די אָנפֿרעג. מיר וועלן מאַכן אַן עקסטרע מענגע פון ​​דער זעלביקער גרייס ווי די לענג פון די געגעבן מענגע. מיר וועלן דורכפירן די אַפּעריישאַנז אויף דעם מענגע און דערהייַנטיקן די אַפּעריישאַנז אויף די געגעבן מענגע.

איצט מיר לויפן אַ שלייף ביז די נומער פון פֿראגן. מיר וועלן דערהייַנטיקן די רעזולטאַט מענגע מיט די אַדישאַן פון די געגעבן ווערט 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) ווו “N” איז די נומער פון עלעמענטן אין די מענגע און "q” איז די נומער פון פֿראגן. זינט מיר האָבן געוויינט אַ צוגאַנג ווי אַ פּרעפיקס סומע, מיר האָבן לינעאַר צייט קאַמפּלעקסיטי.

ספעיס קאַמפּלעקסיטי

 אָ (N) ווו “N” איז די נומער פון עלעמענטן אין דער מענגע.