Skip to content
Related Articles

Related Articles

Check if the frequency of all the digits in a number is same
  • Difficulty Level : Basic
  • Last Updated : 16 Oct, 2020

Given a positive number ‘N’, the task is to find whether ‘N’ is balanced or not. Output ‘YES’ if ‘N’ is a balanced number else ‘NO’.

A number is balanced if the frequency of all the digits in it is same i.e. all the digits appear the same number of times.

Examples: 

Input: N = 1234567890
Output: YES
The frequencies of all the digits are same.
i.e. every digit appears same number of times.

Input: N = 1337
Output: NO

Approach: 

  • Create an array freq[] of size 10 which will store the frequency of each digit in ‘N’.
  • Then, check if all the digits of ‘N’ have the same frequency or not.
  • If yes then print ‘YES’ or ‘NO’ otherwise.

Below is the implementation of the above approach: 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// returns true if the number
// passed as the argument
// is a balanced number.
bool isNumBalanced(int N)
{
 
    string st = to_string(N);
    bool isBalanced = true;
 
    // frequency array to store
    // the frequencies of all
    // the digits of the number
    int freq[10] = { 0 };
    int i = 0;
    int n = st.size();
 
    for (i = 0; i < n; i++)
 
        // store the frequency of
        // the current digit
        freq[st[i] - '0']++;
 
    for (i = 0; i < 9; i++) {
 
        // if freq[i] is not
        // equal to freq[i + 1] at
        // any index 'i' then set
        // isBalanced to false
        if (freq[i] != freq[i + 1])
            isBalanced = false;
    }
 
    // return true if
    // the string is balanced
    if (isBalanced)
        return true;
    else
        return false;
}
 
// Driver code
int main()
{
    int N = 1234567890;
   
    // Function call
    bool flag = isNumBalanced(N);
 
    if (flag)
        cout << "YES";
    else
        cout << "NO";
}
 
// This code is contributed by ihritik


Java




// JAVA implementation using Hashmap and Collection
import java.util.*;
 
public class Num_balanced {
     
    public static boolean isNumBalanced(int n)
    {
        // Calling integer to char array convert function
        char[] num = num_to_arr(n);
         
        // HashMap is used to store key value pairs
        HashMap<Character, Integer> hp
            = new HashMap<Character, Integer>();
         
        // traverse char array and store array elements as
        // key and their frequency as their value
        for (int i = 0; i < num.length; i++)
        {
             
            // if element already exists in the HashMap, so
            // we increment its previous value
            if (hp.containsKey(num[i]))
            {
                hp.put(num[i], hp.get(num[i]) + 1);
            }
             
            // element does'nt exist in the HashMap, so we
            // initialize its value with 1
            else
            {
                hp.put(num[i], 1);
            }
        }
         
        // use Collection to store values of all the keys
        Collection c = (Collection)hp.values();
         
        // use iterator to iterate over each value
        Iterator<?> iterator = c.iterator();
        int temp = (Integer) iterator.next();
 
        while (iterator.hasNext())
        {
            // compare each value to be equal, if not return
            // false
            if ((int) iterator.next() != temp) {
                return false;
            }
        }
         
        // each value was equal so return true
        return true;
    }
     
    // This function converts integer into char array
    public static char[] num_to_arr(int num)
    {
        // Convert integer into String
        String str = Integer.toString(num);
        char[] arr = new char[str.length()];
         
        // Insert characters of the string into char array
        for (int i = 0; i < str.length(); i++) {
            arr[i] = str.charAt(i);
        }
        return arr;
    }
    
    // Driver code
    public static void main(String[] args)
    {
        int n_1 = 1234567890;
 
        // Function call
        if (isNumBalanced(n_1))
        {
            // if number is balanced
            System.out.println("YES");
        }
        else
        
            // if number is not balanced
            System.out.println("NO");
            
        }
    }
}
// Code Contributed by YESHU GARG


Java




// Implementation of JAVA to check the
// given number is Balanced or not
import java.util.*;
public class Main
{
    // returns true if the number
    // passed as the argument
    // is a balanced number.
    public static boolean isNumBalanced(int num)
    {
        // to get the absolute value of the number
        num = Math.abs(num);
 
        // to convert the int number into a String
        String str = num + "";
 
        // to convert the String into Character Array
        char[] ch_arr = str.toCharArray();
 
        // HashSet is used to remove the duplicates
        // in the Character Array
        HashSet<Character> hs = new HashSet<Character>();
        for (char ch : ch_arr)
        {
            // Adding the Characters in the Array in the Set
            hs.add(ch);
        }
        // getting the length of the String
        int str_len = str.length();
 
        // getting the numbers of elemnts in the HashSet
        int hs_len = hs.size();
         
        // return true if
        // the number is balanced
        // checks for the number is balanced or not by
        // comparing length of String and HashSet
        if (hs_len <= str_len / 2 || hs_len == str_len)
        {
            return true;
        }
        return false;
    }
     
    // Driver Code
    public static void main(String[] args)
    {
        int N = 1234567890;
       
        // Function call
        boolean flag = isNumBalanced(N);
 
        if (flag)
            System.out.println("YES");
        else
            System.out.println("NO");
    }
}
// This code is contributed by Mano


Python3




# Python3 implementation of the above approach
 
# Returns true if the number passed as
# the argument is a balanced number.
 
 
def isNumBalanced(N):
 
    st = str(N)
    isBalanced = True
 
    # Frequency array to store the frequencies
    # of all the digits of the number
    freq = [0] * 10
    n = len(st)
 
    for i in range(0, n):
 
        # store the frequency of the
        # current digit
        freq[int(st[i])] += 1
 
    for i in range(0, 9):
 
        # if freq[i] is not equal to
        # freq[i + 1] at any index 'i'
        # then set isBalanced to false
        if freq[i] != freq[i + 1]:
            isBalanced = False
 
    # Return true if the string
    # is balanced
    if isBalanced:
        return True
    else:
        return False
 
 
# Driver code
if __name__ == "__main__":
 
    N = 1234567890
     
    # Function call
    flag = isNumBalanced(N)
 
    if flag:
        print("YES")
    else:
        print("NO")
 
# This code is contributed by Rituraj Jain


C#




// CSHARP implementation of the above approach
using System;
 
class Program
{
    // returns true if the number
    // passed as the argument
    // is a balanced number.
    static bool isNumBalanced(int N)
    {
        String st = "" + N;
        bool isBalanced = true;
         
        // frequency array to store
        // the frequencies of all
        // the digits of the number
        int[] freq = new int[10];
        int i = 0;
        int n = st.Length;
        for (i = 0; i < n; i++)
             
            // store the frequency of
            // the current digit
            freq[st[i] - '0']++;
        for (i = 0; i < 9; i++)
        {
            // if freq[i] is not
            // equal to freq[i + 1] at
            // any index ‘i’ then set
            // isBalanced to false
            if (freq[i] != freq[i + 1])
                isBalanced = false;
        }
         
        // return true if
        // the string is balanced
        if (isBalanced)
            return true;
        else
            return false;
    }
 
    // Driver code
    static void Main()
    {
        int N = 1234567890;
       
        // Function call
        bool flag = isNumBalanced(N);
        if (flag)
            Console.WriteLine("YES");
        else
            Console.WriteLine("NO");
    }
    // This code is contributed by ANKITRAI1
}


PHP




<?php
// PHP implementation of the approach
 
// returns true if the number
// passed as the argument
// is a balanced number.
function isNumBalanced($N)
{
    $st = "" . strval($N);
    $isBalanced = true;
 
    // frequency array to store
    // the frequencies of all
    // the digits of the number
    $freq = array_fill(0, 10, 0);
    $i = 0;
    $n = strlen($st);
 
    for ($i = 0; $i < $n; $i++)
 
        // store the frequency of
        // the current digit
        $freq[ord($st[$i]) - ord('0')]++;
 
    for ($i = 0; $i < 9; $i++)
    {
 
        // if freq[i] is not
        // equal to freq[i + 1] at
        // any index 'i' then set
        // isBalanced to false
        if ($freq[$i] != $freq[$i + 1])
            $isBalanced = false;
    }
 
    // return true if
    // the string is balanced
    if ($isBalanced)
        return true;
    else
        return false;
}
 
// Driver code
$N = 1234567890;
 
// Function call
$flag = isNumBalanced($N);
 
if ($flag)
    echo "YES\n";
else
    echo "NO\n";
 
// This code is contributed by mits
?>


Output

YES

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up
Recommended Articles
Page :