Check if the frequency of all the digits in a number is same

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']++;

    sort(freq,freq+10);
    int k=9; // last index of the array
    while(freq[k-1]!=0){
        if(freq[k]!=freq[k-1]){
            isBalanced=false;
        }
        k--;
    }

    // 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 elements 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
?>

Javascript

<script>

// Javascript implementation of
// the above approach

// Returns true if the number
// passed as the argument
// is a balanced number.
function isNumBalanced(N)
{
    var st = N;
    var isBalanced = true;

    // Frequency array to store
    // the frequencies of all
    // the digits of the number
    var freq = new Array(10);
    var i = 0;
    var 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
var N = 1234567890;

// Function call
var flag = isNumBalanced(N);

if (flag)
    document.write("YES");
else
    document.write("NO");

// This code is contributed by bunnyram19

</script>

Output

NO

Complexity Analysis:

• Time Complexity: O(NlogN), since the complexity for the sort function is n logn
• Auxiliary Complexity: O(1), though there a frequency array but it takes only 10 space which is constant no of spaces hence the overall space complexity is constant