פאַרבייַטן צוויי קאָנסעקוטיווע גלייַך וואַלועס מיט איין גרעסערע  


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

פּראָבלעם סטאַטעמענט  

רעכן איר האָבן אַ ינטאַדזשער מענגע. די פּראָבלעם "רעפּלאַסע צוויי קאָנסעקוטיווע גלייַך וואַלועס מיט איין גרעסערע" פרעגט צו פאַרבייַטן אַלע די פּאָר וואַלועס זאָגן 'אַ' וואָס קומט קאָנסעקוטיוועלי מיט אַ נומער "a + 1" 1 גרעסער ווי זיי (צוויי קאָנסעקוטיווע נומערן), אַזוי אַז אפילו נאָך די מאַדאַפאַקיישאַן אָדער יבערכאַזערונג עס וועט זיין קיין נייַ קאָנסעקוטיווע פּאָר רוען.

בייַשפּיל  

arr[]={5, 2, 1, 1, 2, 2}
5 4

דערקלערונג

ווי 1 איז אַ קאָנסעקוטיווע נומער עס איז ריפּלייסט דורך אַ ווערט גרעסער ווי דעם מיטל 2 און אַרר וועט ווערן {5,2,2,2,2}

איצט 2 איז אַ קאָנסעקוטיווע נומער, אַזוי וועט זיין ריפּלייסט דורך אַ נומער גרעסער ווי עס, דאָס הייסט, 3 און אַרר וועט ווערן {5,3,2,2}

ווידער 2 איז אַ קאָנסעקוטיווע נומער אַזוי וועט זיין ריפּלייסט דורך 3 און אַרר וועט ווערן {5,3,3}

איצט 3 איז די קאָנסעקוטיווע נומער, אַזוי וועט זיין ריפּלייסט דורך 4 און ער וועט ווערן {5,4}

arr[]={2,5,5,6,2,7,7}
2 7 2 8

דערקלערונג

ווי 5 איז אַ קאָנסעקוטיווע נומער עס איז ריפּלייסט מיט אַ ווערט 1 גרעסער ווי אַז מיטל 6. אַזוי אַרר וועט קוקן ווי אַרר [] = {2,6,6,2,7,7}

6 קומען אין פּלאַץ פון דעם אָבער די ווייַטער נומער איז אויך 6, אַזוי עס איז אויך ריפּלייסט מיט די ווערט 1 גרעסער ווי 6, מיטל 7 און ער וועט ווערן {2,7,2,7,7}

ווי 7 אויך ענדלעך אַקערז קאָנסעקוטיוועלי, אַזוי עס איז ריפּלייסט מיט די 8 און ער וועט ווערן {2,7,2,8}

אַלגאָריטהם  

1. Set the position’s value to 0.
2. Traverse the array from o to n(n is the length of the array).
  1. Copy the value of arr[i] to arr[position] and increase the value of the position by 1.
  2. While the position is greater than 1, its previous two values are equal or not.
    1. Decrease the value of a position by 1,
    2. and increase the value of arr[position -1] by 1.
3. Print the array from index 0 to position.

דערקלערונג

זע אויך
שטעלן מאַטריץ זעראָעס

מיר האָבן געגעבן אַן מענגע of ינטאַדזשערז. מיר האָבן געבעטן צו פאַרבייַטן אַלע די וואַלועס וואָס קומען קאָנסעקוטיוועלי מיט אַ נומער 1 גרעסער ווי די נומער זיך. אויב 4 קומען אין ערייזאַז קאָנסעקוטיוועלי, עס וועט זיין ריפּלייסט מיט די ווערט 5. וואָס איז 1 גרעסער ווי די נומער 4. איצט מיט איין דורך, מיר קענען נאָר מאַכן אַ מאַדאַפאַקיישאַן. רעכן, עס זענען 3 נומערן פאָרשטעלן 4, 4, 5. דערנאָך מיר וועט זיין קאַנווערטינג 4, 4 צו 5, און דעמאָלט 5 איז אַ קאָנסעקוטיווע נומער. ווייַל די ווייַטער נומער איז די זעלבע ווי די נומער זיך. אַזוי מיר וועלן טאָן דאָס מיט אַ נעסטעד שלייף.

אַריבער די מענגע פֿון 0 צו N. עפֿן אַ שלייף, אַזוי עס וועט ווערן אַ נעסטעד שלייף. מיט די ויסווייניקסט שלייף, מיר וועלן האַנדלען מיט די טראַווערסאַלס. און מיט די ינער שלייף, מיר וועלן דערהייַנטיקן די וואַלועס אָדער פאַרבייַטן די וואַלועס לויט די געגעבן צושטאַנד. אין די ויסווייניקסט שלייף, מיר וועלן נאָכמאַכן די וואַלועס אין דער זעלביקער מענגע אַרויף צו צוויי וואַלועס.

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

זע אויך
מאַקסימום לענג פון ריפּיטיד סובאַררייַ

איצט דרוקן די מענגע פון ​​0 צו אינדעקס שטעלע וואָס איז לעצט דערהייַנטיקט, עס וועט געבן די געבעטן מענגע.

פאַרבייַטן צוויי קאָנסעקוטיווע גלייַך וואַלועס מיט איין גרעסערע

 

קאָדעקס  

C ++ קאָד צו רעפּלאַסע צוויי קאָנסעקוטיווע גלייַך וואַלועס מיט איין גרעסערע

#include<iostream>

using namespace std;

void replaceValues(int arr[], int n)
{
    int position = 0;

    for (int i = 0; i < n; i++)
    {
        arr[position++] = arr[i];
        while (position > 1 && arr[position - 2] == arr[position - 1])
        {
            position--;
            arr[position - 1]++;
        }
    }
    for (int i = 0; i < position; i++)
        cout << arr[i] << " ";
}
int main()
{
    int arr[] = { 2,5,5,6,2,7,7};
    int n = sizeof(arr) / sizeof(int);
    replaceValues(arr, n);
    return 0;
}
2 7 2 8

דזשאַוואַ קאָד צו פאַרבייַטן צוויי קאָנסעקוטיווע גלייַך וואַלועס מיט איין גרעסערע

class replaceConsecutiveValues
{
    public static void replaceValues(int arr[], int n)
    {
        int position = 0;
        for (int i = 0; i < n; i++)
        {
            arr[position++] = arr[i];
            while (position > 1 && arr[position - 2] == arr[position - 1])
            {
                position--;
                arr[position - 1]++;
            }
        }
        for (int i = 0; i < position; i++)
            System.out.print( arr[i] + " ");
    }
    public static void main(String args[])
    {
        int arr[] = {2,5,5,6,2,7,7};
        int n = arr.length;
        replaceValues (arr, n);
    }
}
2 7 2 8

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

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

אָ (n2ווו“N” איז די נומער פון עלעמענטן אין דער מענגע. ווייַל מיר האָבן געוויינט צוויי נעסטעד לופּס וואָס אַלגערידאַם געלאפן אין פּאָלינאָמיאַל צייט.

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

אָ (1), וואָס איז פרייַ פון די נומער פון עלעמענטן אין דער מענגע. די אַלגערידאַם זיך נעמט קעסיידערדיק פּלאַץ אָבער די פּראָגראַם ווי אַ גאַנץ נעמט אָ (N) פּלאַץ (פֿאַר ינפּוט).