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


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

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

בייַשפּיל  

מוסטער ינפּוט:

[2, 3, 4, 1, 7, 9]

מוסטער רעזולטאַט:

יאָ

דערקלערונג:

עס האט אַ סכום פון קאַנטיניואַס ינטאַדזשערז פון די נומער [2, 3, 4, 1]

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

1. Declare a Set.
2. Add all the elements of an array into the Set.
3. Set count to 1 and currentElement to arr[0]-1.
4. Open a loop, while Set contains the currentElement.
  1. Do count++ and currentElement--.
5. Set currentElement to arr[0]+1.
6. Open a loop, while Set contains the currentElement.
  1. Do count++ and currentElement++.
7. Check if the count is equal to the size of a set, if condition satisfies, then return true.
8. Else return false.

דערקלערונג  

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

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

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

עפֿענען אַ שלייף און עס וועט פאָרזעצן ביז סעט האט די קראַנט עלעמענט אין זיך, ווייַל אין אַ שלייף מיר וועלן פאַרגרעסערן די ציילן פון ציילן מיט 1 (ציילן = ציילן + 1) און פאַרמינערן די ווערט פון קראַנט עלעמענט דורך 1 (קראַנט - 1). באַשטעטיק די ווערט פון קראַנט עלעמענט צו אַרר [0] 1 און עפֿענען אן אנדער שלייף און עס וועט אויך פאָרזעצן ביז סעט האט די קראַנט עלעמענט אין עס, אָבער דאָס מאָל מיר וועלן פאַרגרעסערן ביידע וואַלועס מיט 1 ציילן ++ און קראַנט עלעמענט ++. צום סוף, מיר וועלן קאָנטראָלירן אויב די ווערט פון ציילן איז גלייַך צו די גרייס פון באַשטעטיקן, אויב עס איז געפֿונען צו זיין אמת, און צוריקקומען אמת אַנדערש קערט פאַלש.

לאָמיר באַטראַכטן אַ ביישפּיל:

בייַשפּיל

אַרר [] = {5, 2, 3, 6, 4, 4, 6, 6};

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

שטעלן: {2,3,4,5,6}, ווייַל עס רימוווז דופּליקאַט עלעמענטן

ציילן = 1, קראַנט עלעמענט = אַרר [0] -1 = 4;

  • בשעת באַשטעטיקט CurrentElement (4) איז אמת,

ציילן = ציילן + 1 => ציילן = 2, קראַנט עלעמענט– => קראַנט עלעמענט = 3

  • בשעת באַשטעטיקט CurrentElement (3) איז אמת,

ציילן = ציילן + 1 => ציילן = 3, קראַנט עלעמענט– => קראַנט עלעמענט = 2

  • בשעת באַשטעטיקט CurrentElement (2) איז אמת,
זע אויך
געפֿינען דופּליקאַטן אין אַ געגעבן מענגע ווען עלעמענטן זענען נישט לימיטעד צו אַ קייט

ציילן = ציילן + 1 => ציילן = 4, קראַנט עלעמענט– => קראַנט עלעמענט = 1

  • בשעת באַשטעטיקט CurrentElement (1) איז פאַלש, אַזוי עס קומט אויס פון די שלייף.

באַשטעטיק currentElement [0] = אַרר [0] +1 => currentElement = 6

  • בשעת באַשטעטיקט CurrentElement (6) איז אמת,

ציילן = ציילן + 1 => ציילן = 5, קראַנט עלעמענט ++ => קראַנט עלעמענט = 7

  • בשעת סעט האט קראַנט עלעמענט (7) איז פאַלש אַזוי עס קומט אויס פון די שלייף

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

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

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

#include<iostream>
#include<unordered_set>
using namespace std;
bool areElementsContiguous(int arr[], int n)
{
    unordered_set<int> Set;
    for (int i = 0; i < n; i++)
        Set.insert(arr[i]);

    int count = 1;
    int currentElement = arr[0] - 1;
    while (Set.find(currentElement) != Set.end())
    {
        count++;
        currentElement--;
    }
    currentElement = arr[0] + 1;
    while (Set.find(currentElement) != Set.end())
    {
        count++;
        currentElement++;
    }
    return (count == (int)(Set.size()));
}
int main()
{
    int arr[] = { 5, 2, 3, 6, 4, 4, 6, 6 };
    int n = sizeof(arr) / sizeof(arr[0]);
    if (areElementsContiguous(arr, n))
        cout << "Yes, it is set of contiguous integers.";
    else
        cout << "No, it is not a set of contiguous integers.";
    return 0;
}
Yes, it is set of contiguous integers.

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

import java.util.HashSet;
class contiguousArray
{
    public static Boolean checkContiguousElements(int arr[], int n)
    {
        HashSet<Integer> set = new HashSet<Integer>();
        for (int i = 0; i < n; i++)
        {
            set.add(arr[i]);
        }
        int count = 1;
        int currentElement = arr[0] - 1;
        while (set.contains(currentElement) == true)
        {
            count++;
            currentElement--;
        }
        currentElement = arr[0] + 1;
        while (set.contains(currentElement) == true)
        {
            count++;
            currentElement++;
        }
        return (count == (set.size()));
    }
    public static void main(String[] args)
    {
        int arr[] = { 10, 7, 8, 11, 9, 9, 10, 10 };
        int n = arr.length;
        if (checkContiguousElements(arr, n))
            System.out.println("Yes, it is set of contiguous integers.");
        else
            System.out.println("No, it is not a set of contiguous integers.");
    }
}
Yes, it is set of contiguous integers.

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

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

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

זע אויך
סומע פון ​​f (a [i], a [j]) איבער אַלע פּערז אין אַ מענגע פון ​​N ינטאַדזשערז

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

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