מאַקסימום קאָנסעקוטיווע נומערן פאָרשטעלן אין אַ עריי  


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

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

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

בייַשפּיל  

arr[] = {2, 24, 30, 26, 99, 25}
3

דערקלערונג: די קאָנסעקוטיווע נומערן זענען ⇒ 24, 25, 26 (א סכום פון 3).

arr[] = { -8, 9 , -1, -6, -5}
2

דערקלערונג: די קאָנסעקוטיווע נומערן זענען ⇒ -6, -5 (א סכום פון 2).

אַלגאָריטהם  

1. Declare a set.
2. Do traversing of the array, and insert all the values of array into the Set.
3. Set output to 0.
4. Traverse the array from i=0, to i<n(length of the array).
  1. Check if Set contains the arr[i].
    1. If true, then pick the current array element and store it to temp.
  2. While Set contains the temp, repeatedly increases the values of temp.
  3. Find out the maximum between output and temp-arr[i] and store it into the output.
5. Return output.

דערקלערונג  

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

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

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

מיר איצט האָבן צו געפֿינען אויס די מאַקסימום פון פּראָדוקציע און די חילוק פון טעמפּ-אַרר [איך], טאָן ניט טראַכטן ווי אויב דעם חילוק גיט די פאַלש נומער פון דער ציילן, ווייַל מיר וועלן באַקומען די ינקראַמענטיד ווערט פון טעמפּ ווען מיר קומען אויס פון די שלייף, מיר וועלן באַקומען די ריכטיק ציילן פון קאָנסעקוטיווע נומערן פאָרשטעלן. מיר וועלן דעמאָלט קראָם די מאַקסימום צווישן פּראָדוקציע און די חילוק פון טעמפּ-אַרר [איך] (רעזולטאַט, טעמפּ-אַרר [איך]). Arr [i] איז נאָר אַ סטאַרטינג פונט פֿאַר אַ סעריע פון ​​קאָנסעקוטיווע נומערן און טעמפּ, סאָף פונט. די סטעפּס וועט זיין ריפּיטיד ביז מיר געפֿונען די מאַקסימום רעזולטאַט נאָך דורכפאָר די גאנצע מענגע.

מאַקסימום קאָנסעקוטיווע נומערן פאָרשטעלן אין אַ עריישפּילקע

ימפּלעמענטאַטיאָן  

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

#include<iostream>
#include<unordered_set>

using namespace std;

int getMaxConsecutiveNumber(int arr[], int n)
{
    unordered_set<int> SET;
    for (int i = 0; i < n; i++)
        SET.insert(arr[i]);

    int output = 0;
    for (int i = 0; i < n; i++)
    {
        if (SET.find(arr[i] - 1) == SET.end())
        {
            int temp = arr[i];

            while (SET.find(temp) != SET.end())
                temp++;

            output = max(output, temp - arr[i]);
        }
    }
    return output;
}
int main()
{
    int arr[] = {2, 24, 30, 26, 99, 25 };
    int n = sizeof(arr) / sizeof(int);
    cout << "Largest Set found : "<<getMaxConsecutiveNumber(arr, n)<< endl;
    return 0;
}
Largest Set found : 3

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

import java.util.HashSet;

class LargestConsecutiveSet
{
    public static int getMaxConsecutiveNumber(int arr[], int n)
    {
        HashSet<Integer> SET = new HashSet<Integer>();
        for (int i = 0; i < n; i++)
        {
            SET.add(arr[i]);
        }
        int output = 0;
        for (int i = 0; i < n; i++)
        {
            if(SET.contains(arr[i]))
            {
                int temp = arr[i];
                while (SET.contains(temp))
                    temp ++;

                output = Math.max(output, temp - arr[i]);
            }
        }
        return output;
    }
    public static void main(String[] args)
    {
        int arr[] = {2, 24, 30, 26, 99, 25};
        int n = arr.length;
        System.out.println("Largest Set found : "+getMaxConsecutiveNumber(arr, n));
    }
}
Largest Set found : 3

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

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

אָ (N) ווו “N” איז די נומער פון עלעמענטן אין די מענגע. ווייַל מיר האָבן געוויינט HashSet, וואָס אַלאַוז די ינסערשאַן, דילישאַן און זוכן אָפּעראַציע אין קעסיידערדיק צייט.

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

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

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

דערמאָנען