Compruebe si el número decimal dado tiene solo dígitos 0 y 1

Dado un número entero n , la tarea es verificar si n está en binario o no. Imprime verdadero si n es la representación binaria, de lo contrario imprime falso .

Ejemplos: 

Entrada: n = 1000111 
Salida: verdadero

Entrada: n = 123 
Salida: falso 
 

Método n.º 1: Usando Set Primero agregue todos los dígitos de n en un conjunto, luego elimine 0 y 1 del conjunto, si el tamaño del conjunto se convierte en 0 , entonces el número está en formato binario.

A continuación se muestra la implementación del enfoque anterior:  

// C++ program to check whether the given number
// is in binary format
#include<bits/stdc++.h>
using namespace std;
    // Function that returns true if given number
    // is in binary format  i.e. number contains
    // only 0's and/or 1's
    bool isBinary(int number)
    {
        set<int> set;
  
        // Put all the digits of the number in the set
        while (number > 0) {
            int digit = number % 10;
            set.insert(digit);
            number /= 10;
        }
  
        // Since a HashSet does not allow duplicates so only
        // a single copy of '0' and '1' will be stored
        set.erase(0);
        set.erase(1);
  
        // If the original number only contained 0's and 1's
        // then size of the set must be 0
        if (set.size() == 0) {
            return true;
        }
        return false;
    }
  
    // Driver code
    int main()
    {
        int n = 1000111;
        if(isBinary(n)==1)
            cout<<"true"<<endl;
        else
            cout<<"No"<<endl;
    }
//contributed by Arnab Kundu

// Java program to check whether the given number
// is in binary format
import java.util.HashSet;
import java.util.Set;
 
class GFG {
 
    // Function that returns true if given number
    // is in binary format  i.e. number contains
    // only 0's and/or 1's
    static boolean isBinary(int number)
    {
        Set<Integer> set = new HashSet<>();
 
        // Put all the digits of the number in the set
        while (number > 0) {
            int digit = number % 10;
            set.add(digit);
            number /= 10;
        }
 
        // Since a HashSet does not allow duplicates so only
        // a single copy of '0' and '1' will be stored
        set.remove(0);
        set.remove(1);
 
        // If the original number only contained 0's and 1's
        // then size of the set must be 0
        if (set.size() == 0) {
            return true;
        }
        return false;
    }
 
    // Driver code
    public static void main(String a[])
    {
        int n = 1000111;
        System.out.println(isBinary(n));
    }
}

# Python 3 program to check whether
# the given number is in binary format
 
# Function that returns true if given
# number is in binary format i.e. number
# contains only 0's and/or 1's
def isBinary(number):
    set1 = set()
 
    # Put all the digits of the
    # number in the set
    while(number > 0):
        digit = number % 10
        set1.add(digit)
        number = int(number / 10)
 
    # Since a HashSet does not allow
    # duplicates so only a single copy
    # of '0' and '1' will be stored
    set1.discard(0)
    set1.discard(1)
     
    # If the original number only
    # contained 0's and 1's then
    # size of the set must be 0
    if (len(set1) == 0):
        return True
 
    return False
     
# Driver code
if __name__ == '__main__':
    n = 1000111
    if(isBinary(n) == 1):
        print("true")
    else:
        print("No")
 
# This code is contributed by
# Surendra_Gangwar

     
// C# program to check whether the given number
// is in binary format
using System;
using System.Collections.Generic;
public class GFG {
  
    // Function that returns true if given number
    // is in binary format  i.e. number contains
    // only 0's and/or 1's
    static bool isBinary(int number)
    {
        HashSet<int> set = new HashSet<int>();
  
        // Put all the digits of the number in the set
        while (number > 0) {
            int digit = number % 10;
            set.Add(digit);
            number /= 10;
        }
  
        // Since a HashSet does not allow duplicates so only
        // a single copy of '0' and '1' will be stored
        set.Remove(0);
        set.Remove(1);
  
        // If the original number only contained 0's and 1's
        // then size of the set must be 0
        if (set.Count == 0) {
            return true;
        }
        return false;
    }
  
    // Driver code
    public static void Main()
    {
        int n = 1000111;
        Console.WriteLine(isBinary(n));
    }
}
//This code is contributed by Rajput-Ji

<script>
// Javascript program to check whether the given number
// is in binary format
     
    // Function that returns true if given number
    // is in binary format  i.e. number contains
    // only 0's and/or 1's
    function isBinary(number)
    {
        let set = new Set();
   
        // Put all the digits of the number in the set
        while (number > 0) {
            let digit = number % 10;
            set.add(digit);
            number = Math.floor(number/10);
        }
   
        // Since a HashSet does not allow duplicates so only
        // a single copy of '0' and '1' will be stored
        set.delete(0);
        set.delete(1);
   
        // If the original number only contained 0's and 1's
        // then size of the set must be 0
        if (set.size == 0) {
            return true;
        }
        return false;
    }
     
    // Driver code
    let n = 1000111;
    document.write(isBinary(n));
     
     
// This code is contributed by rag2127
</script>

true

Complejidad de tiempo: O (logN), ya que estamos usando un bucle para atravesar logN veces, ya que en cada recorrido estamos disminuyendo N por división de piso de 10. 

Espacio Auxiliar: O(logN), ya que estamos usando espacio extra para el conjunto.

Método #2: Forma Nativa 

// C++ program to check whether the
// given number is in binary format
#include<bits/stdc++.h>
using namespace std;
 
// Function that returns true if
// given number is in binary format
// i.e. number contains only 0's and/or 1's
int isBinary(int number)
{
    while (number > 0)
    {
        int digit = number % 10;
 
        // If digit is other than 0 and 1
        if (digit > 1)
            return false;
        number /= 10;
    }
    return true;
}
 
// Driver code
int main()
{
  int n = 1000111;
  if (isBinary(n) == 1)
    cout << "true";
  else
    cout << "false";
 
// This code is contributed
// by Shivi_Aggarwal
}

// Java program to check whether the
// given number is in binary format
 
class GFG {
 
    // Function that returns true if
    // given number is in binary format
    // i.e. number contains only 0's and/or 1's
    static boolean isBinary(int number)
    {
        while (number > 0) {
            int digit = number % 10;
 
            // If digit is other than 0 and 1
            if (digit > 1)
                return false;
            number /= 10;
        }
        return true;
    }
 
    // Driver code
    public static void main(String a[])
    {
        int n = 1000111;
        System.out.println(isBinary(n));
    }
}

# Python3 program to check whether the
# given number is in binary format
 
# Function that returns true if
# given number is in binary format
# i.e. number contains only 0's and/or 1's
def isBinary(number):
 
    while (number > 0):
        digit = number % 10
 
        # If digit is other than 0 and 1
        if (digit > 1):
            return False
        number //= 10
     
    return True
 
# Driver code
if __name__ == "__main__":
 
    n = 1000111
    if (isBinary(n) == 1):
        print ("true")
    else:
        print ("false")
 
# This code is contributed by ita_c

// C# program to check whether the
// given number is in binary format
 
using System;
 
class GFG {
 
    // Function that returns true if
    // given number is in binary format
    // i.e. number contains only 0's and/or 1's
    static bool isBinary(int number)
    {
        while (number > 0) {
            int digit = number % 10;
 
            // If digit is other than 0 and 1
            if (digit > 1)
                return false;
            number /= 10;
        }
        return true;
    }
 
    // Driver code
    static void Main()
    {
        int n = 1000111;
        Console.WriteLine(isBinary(n));
    }
    // This code is contributed by Ryuga
}

<?php
// PHP program to check whether the
// given number is in binary format
 
// Function that returns true if
// given number is in binary format
// i.e. number contains only 0's and/or 1's
function isBinary($number)
{
    while ($number > 0)
    {
        $digit = $number % 10;
 
        // If digit is other than 0 and 1
        if ($digit > 1)
            return false;
        $number /= 10;
    }
    return true;
}
 
// Driver code
$n = 1000111;
if (isBinary($n) == 1)
    echo "true";
else
    echo "false";
 
// This code is contributed
// by Mukul Singh

<script>
 
// Javascript program to check whether the
// given number is in binary format
 
// Function that returns true if
// given number is in binary format
// i.e. number contains only 0's and/or 1's
function isBinary(number)
{
    while (number > 0)
    {
        let digit = number % 10;
 
        // If digit is other than 0 and 1
        if (digit > 1)
            return false;
             
        number = Math.floor(number / 10);
    }
    return true;
}
 
// Driver code
let n = 1000111;
 
document.write(isBinary(n));
     
// This code is contributed by avanitrachhadiya2155
 
</script>

true

Complejidad de tiempo : O (logN), ya que estamos usando un bucle para atravesar logN veces, ya que en cada recorrido estamos disminuyendo N por división de piso de 10.

Espacio auxiliar : O(1), ya que no estamos utilizando ningún espacio adicional.