# Find the most frequent digit without using array/string

Given an integer, find the most occurring digit in it. If two or more digits occur same number of times, then return the highest of them. Input integer is given as an int variable, not as a string or array. Use of hash or array or string is not allowed.

Example:

`Input:  x = 12234Output: The most frequent digit is 2Input:  x = 1223377Output: The most frequent digit is 7Input:  x = 5Output: The most frequent digit is 5Input:  x = 1000Output: The most frequent digit is 0`

We strongly recommend you to minimize your browser and try this yourself first.

We could create a map of size 10 and store count of all digits, but use of any array/string is not allowed.
The idea is simple, we write a function that counts occurrences of a given digit in a given integer. Then we count all digits from 0 to 9 in given integer. We keep updating maximum count whenever count becomes more or same as previous count. Below is the implementation.

Implementation:

## C++

 `// Finds maximum occurring digit without using any array/string` `#include ` `using` `namespace` `std;`   `// Simple function to count occurrences of digit d in x` `int` `countOccurrences(``long` `int` `x, ``int` `d)` `{` `    ``int` `count = 0;  ``// Initialize count of digit d` `    ``while` `(x)` `    ``{` `        ``// Increment count if current digit is same as d` `        ``if` `(x%10 == d)` `           ``count++;` `        ``x = x/10;` `    ``}` `    ``return` `count;` `}`   `// Returns the max occurring digit in x` `int` `maxOccurring(``long` `int` `x)` `{` `   ``// Handle negative number` `   ``if` `(x < 0)` `      ``x = -x;`   `   ``int` `result = 0; ``// Initialize result which is a digit` `   ``int` `max_count = 1; ``// Initialize count of result`   `   ``// Traverse through all digits` `   ``for` `(``int` `d=0; d<=9; d++)` `   ``{` `      ``// Count occurrences of current digit` `      ``int` `count = countOccurrences(x, d);`   `      ``// Update max_count and result if needed` `      ``if` `(count >= max_count)` `      ``{` `         ``max_count = count;` `         ``result = d;` `      ``}` `   ``}` `   ``return` `result;` `}`   `// Driver program` `int` `main()` `{` `    ``long` `int` `x = 1223355;` `    ``cout << ``"Max occurring digit is "` `<< maxOccurring(x);` `    ``return` `0;` `}`

## Java

 `// Finds maximum occurring digit` `// without using any array/string` `import` `java.io.*;`   `class` `GFG ` `{` `    `  `// Simple function to count ` `// occurrences of digit d in x` `static` `int` `countOccurrences(``int` `x, ` `                            ``int` `d)` `{` `    ``// Initialize count` `    ``// of digit d` `    ``int` `count = ``0``; ` `    ``while` `(x > ``0``)` `    ``{` `        ``// Increment count if` `        ``// current digit is` `        ``// same as d` `        ``if` `(x % ``10` `== d)` `        ``count++;` `        ``x = x / ``10``;` `    ``}` `    ``return` `count;` `}`   `// Returns the max ` `// occurring digit in x` `static` `int` `maxOccurring( ``int` `x)` `{` `    `  `// Handle negative number` `if` `(x < ``0``)` `    ``x = -x;`   `// Initialize result ` `// which is a digit` `int` `result = ``0``; `   `// Initialize count ` `// of result` `int` `max_count = ``1``; `   `// Traverse through` `// all digits` `for` `(``int` `d = ``0``; d <= ``9``; d++)` `{` `    ``// Count occurrences` `    ``// of current digit` `    ``int` `count = countOccurrences(x, d);`   `    ``// Update max_count` `    ``// and result if needed` `    ``if` `(count >= max_count)` `    ``{` `        ``max_count = count;` `        ``result = d;` `    ``}` `}` `return` `result;` `}`   `// Driver Code` `public` `static` `void` `main (String[] args) ` `{` `    ``int` `x = ``1223355``;` `    ``System.out.println(``"Max occurring digit is "` `+` `                                 ``maxOccurring(x));` `    `  `}` `}`   `// This code is contributed` `// by akt_mit`

## Python3

 `# Finds maximum occurring digit ` `# without using any array/string `   `# Simple function to count ` `# occurrences of digit d in x ` `def` `countOccurrences(x, d):` `    ``count ``=` `0``; ``# Initialize count` `               ``# of digit d ` `    ``while` `(x): ` `        `  `        ``# Increment count if current` `        ``# digit is same as d ` `        ``if` `(x ``%` `10` `=``=` `d):` `            ``count ``+``=` `1``; ` `        ``x ``=` `int``(x ``/` `10``); `   `    ``return` `count; `   `# Returns the max occurring` `# digit in x ` `def` `maxOccurring(x):` `    `  `    ``# Handle negative number ` `    ``if` `(x < ``0``):` `        ``x ``=` `-``x;` `    `  `    ``result ``=` `0``; ``# Initialize result ` `                ``# which is a digit` `    ``max_count ``=` `1``; ``# Initialize count ` `                   ``# of result ` `    `  `    ``# Traverse through all digits` `    ``for` `d ``in` `range``(``10``):` `        `  `        ``# Count occurrences of current digit` `        ``count ``=` `countOccurrences(x, d);` `        `  `        ``# Update max_count and ` `        ``# result if needed` `        ``if` `(count >``=` `max_count):` `            ``max_count ``=` `count;` `            ``result ``=` `d;` `        `  `    ``return` `result; `   `# Driver Code ` `x ``=` `1223355``; ` `print``(``"Max occurring digit is"``, ` `              ``maxOccurring(x)); `   `# This code is contributed by mits.`

## C#

 `// Finds maximum occurring digit` `// without using any array/string` `class` `GFG ` `{` `    `  `// Simple function to count ` `// occurrences of digit d in x` `static` `int` `countOccurrences(``int` `x, ``int` `d)` `{` `    ``// Initialize count` `    ``// of digit d` `    ``int` `count = 0; ` `    ``while` `(x > 0)` `    ``{` `        ``// Increment count if` `        ``// current digit is` `        ``// same as d` `        ``if` `(x % 10 == d)` `        ``count++;` `        ``x = x / 10;` `    ``}` `    ``return` `count;` `}`   `// Returns the max ` `// occurring digit in x` `static` `int` `maxOccurring( ``int` `x)` `{` `    `  `// Handle negative number` `if` `(x < 0)` `    ``x = -x;`   `// Initialize result ` `// which is a digit` `int` `result = 0; `   `// Initialize count ` `// of result` `int` `max_count = 1; `   `// Traverse through` `// all digits` `for` `(``int` `d = 0; d <= 9; d++)` `{` `    ``// Count occurrences` `    ``// of current digit` `    ``int` `count = countOccurrences(x, d);`   `    ``// Update max_count` `    ``// and result if needed` `    ``if` `(count >= max_count)` `    ``{` `        ``max_count = count;` `        ``result = d;` `    ``}` `}` `return` `result;` `}`   `// Driver Code` `static` `void` `Main() ` `{` `    ``int` `x = 1223355;` `    ``System.Console.WriteLine(``"Max occurring digit is "` `+ ` `                                       ``maxOccurring(x));` `}` `}`   `// This code is contributed by mits`

## Javascript

 ``

## PHP

 `= ``\$max_count``) ` `    ``{ ` `        ``\$max_count` `= ``\$count``; ` `        ``\$result` `= ``\$d``; ` `    ``} ` `} ` `return` `\$result``; ` `} `   `// Driver Code ` `\$x` `= 1223355; ` `echo` `"Max occurring digit is "` `. ` `               ``maxOccurring(``\$x``); `   `// This code is contributed by mits` `?>`

Output

```Max occurring digit is 5

```

Time Complexity: O(log10x)
Auxiliary Space: O(1)

Approach#2: using division and modulus operator.

Count the frequency of each digit using division and modulus operator.

Algorithm

1. Initialize a variable “max_freq” to store the maximum frequency of any digit.
2. Initialize a variable “most_frequent_digit” to store the most frequent digit.
3. Repeat the following steps for each digit in the input number:
a. Initialize a variable “count” to 0.
b. Divide the input number by 10 repeatedly until it becomes 0 or less.
c. If the remainder of the division is equal to the current digit, increment “count”.
d. If “count” is greater than “max_freq”, update “max_freq” to “count” and “most_frequent_digit” to the current digit.
4. Return “most_frequent_digit”.

## Java

 `public` `class` `GFG {`   `    ``// Function to find the most frequent digit in a number` `    ``static` `int` `mostFrequentDigit(``int` `x) {` `        ``int` `maxFreq = ``0``;` `        ``int` `mostFrequentDigit = x % ``10``;` `        ``while` `(x > ``0``) {` `            ``int` `digit = x % ``10``;` `            ``int` `count = ``0``;` `            ``int` `temp = x;` `            ``while` `(temp > ``0``) {` `                ``if` `(temp % ``10` `== digit) {` `                    ``count++;` `                ``}` `                ``temp /= ``10``;` `            ``}` `            ``if` `(count > maxFreq) {` `                ``maxFreq = count;` `                ``mostFrequentDigit = digit;` `            ``}` `            ``x /= ``10``;` `        ``}` `        ``return` `mostFrequentDigit;` `    ``}`   `    ``public` `static` `void` `main(String[] args) {` `        ``int` `x = ``1223355``;` `        ``System.out.println(mostFrequentDigit(x));` `    ``}` `}`

## Python3

 `def` `most_frequent_digit(x):` `    ``max_freq ``=` `0` `    ``most_frequent_digit ``=` `x ``%` `10` `    ``while` `x > ``0``:` `        ``digit ``=` `x ``%` `10` `        ``count ``=` `0` `        ``temp ``=` `x` `        ``while` `temp > ``0``:` `            ``if` `temp ``%` `10` `=``=` `digit:` `                ``count ``+``=` `1` `            ``temp ``/``/``=` `10` `        ``if` `count > max_freq:` `            ``max_freq ``=` `count` `            ``most_frequent_digit ``=` `digit` `        ``x ``/``/``=` `10` `    ``return` `most_frequent_digit`   `x ``=` `1223355` `print``(most_frequent_digit(x))`

## Javascript

 `// This function returns the most frequent digit in a given number` `function` `most_frequent_digit(x) {` `    ``let max_freq = 0;` `    ``let most_frequent_digit = x % 10;` `    `  `    ``// Loop through each digit of the number` `    ``while` `(x > 0) {` `        ``let digit = x % 10;` `        ``let count = 0;` `        ``let temp = x;` `        `  `        ``// Count the number of occurrences of the current digit in the number` `        ``while` `(temp > 0) {` `            ``if` `(temp % 10 == digit) {` `                ``count += 1;` `            ``}` `            ``temp = Math.floor(temp / 10);` `        ``}` `        `  `        ``// If the current digit occurs more frequently than the previous most frequent digit, update the most frequent digit` `        ``if` `(count > max_freq) {` `            ``max_freq = count;` `            ``most_frequent_digit = digit;` `        ``}` `        ``x = Math.floor(x / 10);` `    ``}` `    ``return` `most_frequent_digit;` `}`   `// Example usage` `let x = 1223355;` `console.log(most_frequent_digit(x));`

Output

```5

```

Time complexity: O(d * log10(x)), where d is the number of digits in the input number.
Auxiliary Space: O(1)

Whether you're preparing for your first job interview or aiming to upskill in this ever-evolving tech landscape, GeeksforGeeks Courses are your key to success. We provide top-quality content at affordable prices, all geared towards accelerating your growth in a time-bound manner. Join the millions we've already empowered, and we're here to do the same for you. Don't miss out - check it out now!