Check if array contains contiguous integers with duplicates allowed

// Sorting based C# implementation 
// to check whether the array 
// contains a set of contiguous
// integers
using System;

class GFG {
    
    // function to check whether 
    // the array contains a set
    // of contiguous integers
    static bool areElementsContiguous(int []arr,
                                            int n)
    {
    // Sort the array
    Array.Sort(arr);
    
    // After sorting, check if 
    // current element is either
    // same as previous or is 
    // one more.
    for (int i = 1; i < n; i++)
        if (arr[i] - arr[i - 1] > 1)
            return false;
    
    return true; 
    }
    
    // Driver program 
    public static void Main() 
    {
        int []arr = { 5, 2, 3, 6,
                    4, 4, 6, 6 };
        int n = arr.Length;
        
        if (areElementsContiguous(arr, n))
            Console.WriteLine("Yes");
        
        else
            Console.WriteLine("No");
        
    }
    
}
    
// This code is contributed by Vt_m. 

using System;
using System.Linq;
using System.Collections.Generic;
public class GFG {
    static bool AreElementsContiguous(int[] arr)
    {
        // Declaring and Initializing the HashSet
        HashSet<int> s = new HashSet<int>(arr);
        // Finding the size of the HashSet
        int setSize = s.Count;
        // Finding the maximum and minimum elements
        int max = arr.Max();
        int min = arr.Min();

        int result = max - min + 1;
        if (result != setSize) {
            return false;
        }

        return true;
    }

    static void Main(string[] args)
    {
        int[] arr = { 5, 2, 3, 6, 4, 4, 6, 6 };
        if (AreElementsContiguous(arr)) {
            Console.WriteLine("Yes");
        }
        else {
            Console.WriteLine("No");
        }
    }
}
// This code is contributed by Shivam Tiwari

// C# implementation to check whether 
// the array contains a set of 
// contiguous integers
using System;

class GFG {
    
    // function to check whether the 
    // array contains a set of
    // contiguous integers
    static bool areElementsContiguous(
                        int []arr, int n)
    { 
        
        // Find maximum and 
        // minimum elements.
        int max = int.MinValue;
        int min = int.MaxValue;
        
        for(int i = 0; i < n; i++)
        {
            max = Math.Max(max, arr[i]);
            min = Math.Min(min, arr[i]);
        }
    
        int m = max - min + 1;
    
        // There should be at least 
        // m elements in array to
        // make them contiguous.
        if (m > n)
            return false;
        
        // Create a visited array 
        // and initialize false.
        bool []visited = new bool[n];
        
    
        // Mark elements as true.
        for (int i = 0; i < n; i++) 
            visited[arr[i] - min] = true;
    
        // If any element is not 
        // marked, all elements
        // are not contiguous.
        for (int i = 0; i < m; i++)
            if (visited[i] == false)
                return false;
    
        return true;
    }
    
    /* Driver program */
    public static void Main() 
    {
        int []arr = { 5, 2, 3, 6,
                    4, 4, 6, 6 };
                        
        int n = arr.Length;
        
        if (areElementsContiguous(arr, n))
            Console.Write("Yes");
        else
            Console.Write("No");
    }
}

// This code is contributed by nitin mittal.

using System;
using System.Collections.Generic;

// c# implementation to check whether the array 
// contains a set of contiguous integers 

public class GFG
{
    // Function to check whether the array  
    // contains a set of contiguous integers 
    public static bool? areElementsContiguous(int[] arr, int n)
    {
        // Storing elements of 'arr[]' in  
        // a hash table 'us' 
        HashSet<int> us = new HashSet<int>();

        for (int i = 0; i < n; i++)
        {
            us.Add(arr[i]);
        }

        // As arr[0] is present in 'us' 
        int count = 1;

        // Starting with previous smaller  
        // element of arr[0] 
        int curr_ele = arr[0] - 1;

        // If 'curr_ele' is present in 'us' 
        while (us.Contains(curr_ele) == true)
        {

            // increment count 
            count++;

            // update 'curr_ele" 
            curr_ele--;
        }

        // Starting with next greater  
        // element of arr[0] 
        curr_ele = arr[0] + 1;

        // If 'curr_ele' is present in 'us' 
        while (us.Contains(curr_ele) == true)
        {

            // increment count 
            count++;

            // update 'curr_ele" 
            curr_ele++;
        }

        // Returns true if array contains a set of 
        // contiguous integers else returns false 
        return (count == (us.Count));
    }

    // Driver Code 
    public static void Main(string[] args)
    {
        int[] arr = new int[] {5, 2, 3, 6, 4, 4, 6, 6};
        int n = arr.Length;

        if (areElementsContiguous(arr, n).Value)
        {
            Console.WriteLine("Yes");
        }
        else
        {
            Console.WriteLine("No");
        }
    }
}

// This code is contributed by Shrikant13

using System;
using System.Collections.Generic;

class Program {
    // Function to check if array contains contiguous
    // elements
    static bool AreElementsContiguous(int[] arr)
    {
        // Create a HashSet to store unique elements from
        // the array
        HashSet<int> set = new HashSet<int>();

        // Insert all elements into the HashSet
        foreach(int num in arr) { set.Add(num); }

        // Initialize the variable to store the length of
        // the longest contiguous subsequence
        int longestStreak = 0;

        // Iterate through the HashSet
        foreach(int num in set)
        {
            // If the previous element (num - 1) is not in
            // the HashSet, it can be the start of a
            // subsequence
            if (!set.Contains(num - 1)) {
                int currentNum = num;
                int currentStreak = 1;

                // Count the length of the current
                // contiguous subsequence
                while (set.Contains(currentNum + 1)) {
                    currentStreak++;
                    currentNum++;
                }

                // Update the longest contiguous subsequence
                // length
                longestStreak = Math.Max(longestStreak,
                                         currentStreak);
            }
        }

        // If the size of the HashSet is equal to the length
        // of the longest contiguous subsequence, return
        // true
        return set.Count == longestStreak;
    }

    static void Main()
    {
        int[] arr = { 5, 2, 3, 6, 4, 4, 6, 6 };

        if (AreElementsContiguous(arr)) {
            Console.WriteLine(
                "Yes"); // If the array contains contiguous
                        // elements
        }
        else {
            Console.WriteLine(
                "No"); // If the array doesn't contain
                       // contiguous elements
        }
    }
}