Print missing elements that lie in range 0 – 99

Given an array of integers print the missing elements that lie in range 0-99. If there are more than one missing, collate them, otherwise just print the number.
Note that the input array may not be sorted and may contain numbers outside the range [0-99], but only this range is to be considered for printing missing elements.

Examples :

Input: {88, 105, 3, 2, 200, 0, 10}
Output: 1
        4-9
        11-87
        89-99


Input: {9, 6, 900, 850, 5, 90, 100, 99}
Output: 0-4
        7-8
        10-89
        91-98

Expected time complexity O(n), where n is the size of the input array.

The idea is to use a boolean array of size 100 to keep track of array elements that lie in range 0 to 99. We first traverse input array and mark such present elements in the boolean array. Once all present elements are marked, the boolean array is used to print missing elements. 

Following is the implementation of above idea.  

C++

// C++ program for print missing elements
#include <bits/stdc++.h>
#define LIMIT 100
using namespace std;

// A O(n) function to print missing elements in an array
void printMissing(int arr[], int n)
{
    // Initialize all number from 0 to 99 as NOT seen
    bool seen[LIMIT] = {false};

    // Mark present elements in range [0-99] as seen
    for (int i=0; i<n; i++)
    if (arr[i] < LIMIT)
    seen[arr[i]] = true;

    // Print missing element
    int i = 0;
    while (i < LIMIT)
    {
        // If i is missing
        if (seen[i] == false)
        {
            // Find if there are more missing elements after i
            int j = i+1;
            while (j < LIMIT && seen[j] == false)
                j++;

            // Print missing single or range
            (i+1 == j)? cout  <<  i : cout << "\n" << i << "-" << j-1;

            // Update u
            i = j;
        }
        else
            i++;
    }
}

// Driver program
int main()
{
    int arr[] = {88, 105, 3, 2, 200, 0, 10};
    int n = sizeof(arr)/sizeof(arr[0]);
    printMissing(arr, n);
    return 0;
}
// This code is contributed by shivanisinghss2110

C

// C program for print missing elements
#include<stdio.h>
#define LIMIT 100

// A O(n) function to print missing elements in an array
void printMissing(int arr[], int n)
{
    // Initialize all number from 0 to 99 as NOT seen
    bool seen[LIMIT] = {false};

    // Mark present elements in range [0-99] as seen
    for (int i=0; i<n; i++)
      if (arr[i] < LIMIT)
       seen[arr[i]] = true;

    // Print missing element
    int i = 0;
    while (i < LIMIT)
    {
        // If i is missing
        if (seen[i] == false)
        {
            // Find if there are more missing elements after i
            int j = i+1;
            while (j < LIMIT && seen[j] == false)
                  j++;

            // Print missing single or range
            (i+1 == j)? printf("%dn", i): printf("%d-%dn", i, j-1);

            // Update u
            i = j;
        }
        else
            i++;
    }
}

// Driver program
int main()
{
    int arr[] = {88, 105, 3, 2, 200, 0, 10};
    int n = sizeof(arr)/sizeof(arr[0]);
    printMissing(arr, n);
    return 0;
}

Java

class PrintMissingElement
{
    // A O(n) function to print missing elements in an array
    void printMissing(int arr[], int n)
    {
        int LIMIT = 100;

        boolean seen[] = new boolean[LIMIT];

        // Initialize all number from 0 to 99 as NOT seen
        for (int i = 0; i < LIMIT; i++)
            seen[i] = false;

        // Mark present elements in range [0-99] as seen
        for (int i = 0; i < n; i++)
        {
            if (arr[i] < LIMIT)
                seen[arr[i]] = true;
        }

        // Print missing element
        int i = 0;
        while (i < LIMIT)
        {
            // If i is missing
            if (seen[i] == false)
            {
                // Find if there are more missing elements after i
                int j = i + 1;
                while (j < LIMIT && seen[j] == false)
                    j++;

                // Print missing single or range
                int p = j-1;
                System.out.println(i+1==j ? i : i + "-" + p);

                // Update u
                i = j;
            }
            else
                i++;
        }
    }

    // Driver program to test above functions
    public static void main(String[] args)
    {
        PrintMissingElement missing = new PrintMissingElement();
        int arr[] = {88, 105, 3, 2, 200, 0, 10};
        int n = arr.length;
        missing.printMissing(arr, n);
    }
}

Python3

# Python3 program for print missing elements

# A O(n) function to print missing elements in an array
def printMissing(arr, n) :
    LIMIT = 100
    seen = [False]*LIMIT

    # Initialize all number from 0 to 99 as NOT seen
    for i in range(LIMIT) :
      seen[i] = False

    # Mark present elements in range [0-99] as seen
    for i in range(n) :
      if (arr[i] < LIMIT) :
        seen[arr[i]] = True

    # Print missing element
    i = 0
    while (i < LIMIT) :

      # If i is missing
      if (seen[i] == False) :

        # Find if there are more missing elements after i
        j = i + 1
        while (j < LIMIT and seen[j] == False) :
          j += 1

        # Print missing single or range
        p = j - 1
        if(i + 1 == j) :
          print(i)

        else :
          print(i, "-", p)

        # Update u
        i = j

      else :
        i += 1

  # Driver code
arr = [88, 105, 3, 2, 200, 0, 10]
n = len(arr)
printMissing(arr, n)

# This code is contributed by divyesh072019.

C#

using System;
class GFG
{

  // A O(n) function to print missing elements in an array
  static void printMissing(int[] arr, int n)
  {
    int LIMIT = 100;
    bool[] seen = new bool[LIMIT];
    int i;

    // Initialize all number from 0 to 99 as NOT seen
    for (i = 0; i < LIMIT; i++)
      seen[i] = false;

    // Mark present elements in range [0-99] as seen
    for (i = 0; i < n; i++)
    {
      if (arr[i] < LIMIT)
        seen[arr[i]] = true;
    }

    // Print missing element
    i = 0;
    while (i < LIMIT)
    {
      // If i is missing
      if (seen[i] == false)
      {
        // Find if there are more missing elements after i
        int j = i + 1;
        while (j < LIMIT && seen[j] == false)
          j++;

        // Print missing single or range
        int p = j - 1;
        if(i + 1 == j)
        {
          Console.WriteLine(i);
        }
        else
        {
          Console.WriteLine(i + "-" + p);
        }

        // Update u
        i = j;
      }
      else
        i++;
    }
  }

  // Driver code
  static void Main()
  {
    int[] arr = {88, 105, 3, 2, 200, 0, 10};
    int n = arr.Length;
    printMissing(arr, n);
  }
}

// This code is contributed by divyeshrabadiya07.

PHP

<?php
// PHP program for print
// missing elements
$LIMIT= 100;

// A O(n) function to print
// missing elements in an array
function printMissing($arr, $n)
{
    global $LIMIT;

    // Initialize all number from
    // 0 to 99 as NOT seen
    $seen = (false);

    // Mark present elements in.
    // range [0-99] as seen
    for ($i = 0; $i < $n; $i++)
    if ($arr[$i] < $LIMIT)
    $seen[$arr[$i]] = true;

    // Print missing element
    $i = 0;
    while ($i < $LIMIT)
    {
        // If i is missing
        if ($seen[$i] == false)
        {
            // Find if there are more
            // missing elements after i
            $j = $i + 1;
            while ($j < $LIMIT &&
                   $seen[$j] == false)
                $j++;

            // Print missing
            // single or range
            if (($i + 1 == $j) == true)

            echo $i, "\n";
            else
            echo $i , "-", $j - 1, "\n";

            // Update u
            $i = $j;
        }
        else
            $i++;
    }
}

// Driver Code
$arr = array (88, 105, 3, 2,
              200, 0, 10);
$n = sizeof($arr);
printMissing($arr, $n);

// This code is contributed by aj_36
?>

Javascript

<script>

// Javascript program for print missing elements

// A O(n) function to print missing
// elements in an array
function printMissing(arr, n)
{
    let LIMIT = 100;
    let seen = new Array(LIMIT);
    let i;

    // Initialize all number from
    // 0 to 99 as NOT seen
    for(i = 0; i < LIMIT; i++)
        seen[i] = false;

    // Mark present elements in
    // range [0-99] as seen
    for(i = 0; i < n; i++)
    {
        if (arr[i] < LIMIT)
            seen[arr[i]] = true;
    }

    // Print missing element
    i = 0;
    while (i < LIMIT)
    {
        // If i is missing
        if (seen[i] == false)
        {

            // Find if there are more missing
            // elements after i
            let j = i + 1;
            while (j < LIMIT && seen[j] == false)
                j++;

            // Print missing single or range
            let p = j - 1;

            if (i + 1 == j)
            {
                document.write(i + "</br>");
            }
            else
            {
                document.write(i + "-" + p + "</br>");
            }

            // Update u
            i = j;
        }
        else
            i++;
    }
}

// Driver code
let arr = [88, 105, 3, 2, 200, 0, 10];
let n = arr.length;

printMissing(arr, n);

// This code is contributed by suresh07

</script>

Output

1
4-9
11-87
89-99

Time complexity: O(n)
Auxiliary Space: O(1)