అనుమతించబడిన నకిలీలతో శ్రేణి పూర్ణాంకాలను కలిగి ఉందో లేదో తనిఖీ చేయండి  


కఠినత స్థాయి మీడియం
తరచుగా అడుగుతుంది యాక్సెంచర్ అమెజాన్ డైరెక్టి <span style="font-family: Mandali; ">ఫేస్‌బుక్ </span> Intuit
అర్రే హాష్ స్ట్రింగ్

మీకు ఇవ్వబడింది అమరిక నకిలీ మూలకాలను కలిగి ఉండే పూర్ణాంకాల. సమస్య స్టేట్మెంట్ ఇది పూర్ణాంక పూర్ణాంకాల సమితి కాదా అని తెలుసుకోవడానికి అడుగుతుంది, “అవును” అని ముద్రించండి, లేకపోతే “లేదు” అని ముద్రించండి.

ఉదాహరణ  

నమూనా ఇన్పుట్:

[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.

వివరణ  

ఇచ్చిన శ్రేణికి సమితి ఉందో లేదో తెలుసుకోవడానికి మాకు ఒక ప్రశ్న ఇవ్వబడుతుంది పక్కపక్క పూర్ణాంకాలు. అది ఉంటే ప్రింట్ అవును లేకపోతే ప్రింట్ నం. మనం a ను ఉపయోగించబోతున్నాం సెట్ ఇది అన్ని నకిలీ అంశాలను తీసివేసి, మా పనిని సులభతరం చేస్తుంది. కొన్ని నకిలీ మూలకాలు ఉన్న అనేక అంశాలు ఉంటే సెట్ భవిష్యత్తును అందిస్తుంది. అప్పుడు అది అన్ని నకిలీలను తీసివేసి, విభిన్న అంశాలను మాత్రమే కలిగి ఉంటుంది.

ఇది కూడ చూడు
ఇచ్చిన రెండు సెట్లు అస్తవ్యస్తంగా ఉన్నాయో లేదో ఎలా తనిఖీ చేయాలి?

మేము శ్రేణిని దాటడం ద్వారా అన్ని అంశాలను చొప్పించబోతున్నాము సెట్ మరియు ఇది ఇప్పుడు విభిన్న అంశాలను కలిగి ఉంటుంది. కౌంట్ విలువను 1 కి సెట్ చేయండి మరియు తరువాత ఆపరేషన్లలో దాన్ని పెంచుతూనే ఉంటాము. ఇది పూర్ణాంకాల యొక్క సమితి సమితి యొక్క పరిమాణాన్ని తనిఖీ చేస్తుంది ఎందుకంటే శ్రేణిలో పరస్పర పూర్ణాంకాలు లేనట్లయితే ఇది సెట్ కంటే భిన్నమైన పరిమాణాన్ని కలిగి ఉంటుంది. అర్రే [0] -1 ప్రస్తుత ఎలిమెంట్ యొక్క విలువ అవుతుంది. ఇది సమితిపై నిఘా ఉంచుతుంది పూర్ణాంకాల.

ఒక లూప్‌ను తెరవండి మరియు సెట్‌లో కరెంట్ ఎలిమెంట్ ఉండే వరకు ఇది కొనసాగుతుంది, ఎందుకంటే ఒక లూప్‌లో మనం కౌంట్ విలువను 1 (కౌంట్ = కౌంట్ + 1) పెంచబోతున్నాం మరియు కరెంట్ ఎలిమెంట్ విలువను 1 (కరెంట్ ఎలిమెంట్ = కరెంట్ ఎలిమెంట్) తగ్గించబోతున్నాం. - 1). కరెంట్ ఎలిమెంట్ యొక్క విలువను అర్ [0] +1 కు సెట్ చేయండి మరియు మరొక లూప్ తెరవండి మరియు సెట్లో కరెంట్ ఎలిమెంట్ ఉన్నంత వరకు ఇది కొనసాగుతుంది, అయితే ఈసారి మనం రెండు విలువలను 1 కౌంట్ ++ మరియు కరెంట్ ఎలిమెంట్ ++ ద్వారా పెంచుతాము. చివరికి, గణన విలువ సెట్ పరిమాణానికి సమానంగా ఉందో లేదో మేము తనిఖీ చేస్తాము, అది నిజమని తేలితే నిజమైనది అని తిరిగి ఇవ్వండి, తప్పుడు తిరిగి ఇవ్వండి.

ఒక ఉదాహరణను పరిశీలిద్దాం:

ఉదాహరణ

arr [] = {5, 2, 3, 6, 4, 4, 6, 6};

శ్రేణిని దాటిన తరువాత, మనకు ఈ క్రింది విలువలు సెట్‌లో ఉంటాయి.

సెట్ చేయండి: 2,3,4,5,6 XNUMX}, ఎందుకంటే ఇది నకిలీ మూలకాలను తొలగిస్తుంది

కౌంట్ = 1, కరెంట్ ఎలిమెంట్ = అర్ర్ [0] -1 = 4;

  • సెట్‌లో కరెంట్ ఎలిమెంట్ (4) నిజం అయితే,

కౌంట్ = కౌంట్ + 1 => కౌంట్ = 2, కరెంట్ ఎలిమెంట్– => కరెంట్ ఎలిమెంట్ = 3

  • సెట్‌లో కరెంట్ ఎలిమెంట్ (3) నిజం అయితే,

కౌంట్ = కౌంట్ + 1 => కౌంట్ = 3, కరెంట్ ఎలిమెంట్– => కరెంట్ ఎలిమెంట్ = 2

  • సెట్‌లో కరెంట్ ఎలిమెంట్ (2) నిజం అయితే,
ఇది కూడ చూడు
మూలకాలు పరిధికి పరిమితం కానప్పుడు ఇచ్చిన శ్రేణిలో నకిలీలను కనుగొనండి

కౌంట్ = కౌంట్ + 1 => కౌంట్ = 4, కరెంట్ ఎలిమెంట్– => కరెంట్ ఎలిమెంట్ = 1

  • సెట్‌లో కరెంట్ ఎలిమెంట్ (1) తప్పు అయితే, ఇది లూప్ నుండి బయటకు వస్తుంది.

ప్రస్తుత ఎలిమెంట్‌ను సెట్ చేయండి [0] = arr [0] +1 => currentElement = 6

  • సెట్‌లో కరెంట్ ఎలిమెంట్ (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” శ్రేణిలోని మూలకాల సంఖ్య.