Given an octal number **N**, the task is to convert the number to decimal and then find the modulo with every power of **2** i.e. **2 ^{i}** such that

**i > 0**and

**2**and print the maximum frequency of the modulo.

^{i}< N**Examples:**

Input:N = 13

Output:2

Octal(13) = decimal(11)

11 % 2 = 1

11 % 4 = 3

11 % 8 = 3

3 occurs the most i.e. 2 times.

Input:N = 21

Output:4

**Approach:** Find the binary representation of the number by replacing the digit with their binary representation. Now it is known that every digit in the binary representation represents a power of 2 in increasing order. So the modulo of the number with a power of 2 is the number formed by the binary representation of its preceding bits. For Example,

Octal(13) = decimal(11) = binary(1011)

So,

11(1011) % 2 (10) = 1 (1)

11(1011) % 4 (100) = 3 (11)

11(1011) % 8 (1000) = 3 (011)

Here, it can be observed that when there is a zero in the binary representation of the modulo, the number remains the same. So the maximum frequency of the modulo will be 1 + the number of consecutive 0’s in the binary representation (not the leading zeroes) of the number. As the modulo starts from 2, remove the LSB of the number.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Binary representation of the digits ` `const` `string bin[] = { ` `"000"` `, ` `"001"` `, ` `"010"` `, ` `"011"` `, ` ` ` `"100"` `, ` `"101"` `, ` `"110"` `, ` `"111"` `}; ` ` ` `// Function to return the maximum frequency ` `// of s modulo with a power of 2 ` `int` `maxFreq(string s) ` `{ ` ` ` ` ` `// Store the binary representation ` ` ` `string binary = ` `""` `; ` ` ` ` ` `// Convert the octal to binary ` ` ` `for` `(` `int` `i = 0; i < s.length(); i++) { ` ` ` `binary += bin[s[i] - ` `'0'` `]; ` ` ` `} ` ` ` ` ` `// Remove the LSB ` ` ` `binary = binary.substr(0, binary.length() - 1); ` ` ` ` ` `int` `count = 1, prev = -1, i, j = 0; ` ` ` ` ` `for` `(i = binary.length() - 1; i >= 0; i--, j++) ` ` ` ` ` `// If there is 1 in the binary representation ` ` ` `if` `(binary[i] == ` `'1'` `) { ` ` ` ` ` `// Find the number of zeroes in between ` ` ` `// two 1's in the binary representation ` ` ` `count = max(count, j - prev); ` ` ` `prev = j; ` ` ` `} ` ` ` ` ` `return` `count; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `string octal = ` `"13"` `; ` ` ` ` ` `cout << maxFreq(octal); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java implementation of the approach ` `class` `GFG ` `{ ` ` ` `// Binary representation of the digits ` `static` `String bin[] = { ` `"000"` `, ` `"001"` `, ` `"010"` `, ` `"011"` `, ` ` ` `"100"` `, ` `"101"` `, ` `"110"` `, ` `"111"` `}; ` ` ` `// Function to return the maximum frequency ` `// of s modulo with a power of 2 ` `static` `int` `maxFreq(String s) ` `{ ` ` ` ` ` `// Store the binary representation ` ` ` `String binary = ` `""` `; ` ` ` ` ` `// Convert the octal to binary ` ` ` `for` `(` `int` `i = ` `0` `; i < s.length(); i++) ` ` ` `{ ` ` ` `binary += bin[s.charAt(i) - ` `'0'` `]; ` ` ` `} ` ` ` ` ` `// Remove the LSB ` ` ` `binary = binary.substring(` `0` `, ` ` ` `binary.length() - ` `1` `); ` ` ` ` ` `int` `count = ` `1` `, prev = -` `1` `, i, j = ` `0` `; ` ` ` ` ` `for` `(i = binary.length() - ` `1` `; ` ` ` `i >= ` `0` `; i--, j++) ` ` ` ` ` `// If there is 1 in the binary representation ` ` ` `if` `(binary.charAt(i) == ` `'1'` `) ` ` ` `{ ` ` ` ` ` `// Find the number of zeroes in between ` ` ` `// two 1's in the binary representation ` ` ` `count = Math.max(count, j - prev); ` ` ` `prev = j; ` ` ` `} ` ` ` `return` `count; ` `} ` ` ` `// Driver code ` `public` `static` `void` `main(String []args) ` `{ ` ` ` `String octal = ` `"13"` `; ` ` ` ` ` `System.out.println(maxFreq(octal)); ` `} ` `} ` ` ` `// This code is contributed by 29AjayKumar ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 implementation of the approach ` ` ` `# Binary representation of the digits ` `bin` `=` `[ ` `"000"` `, ` `"001"` `, ` `"010"` `, ` `"011"` `, ` ` ` `"100"` `, ` `"101"` `, ` `"110"` `, ` `"111"` `]; ` ` ` `# Function to return the maximum frequency ` `# of s modulo with a power of 2 ` `def` `maxFreq(s) : ` ` ` ` ` `# Store the binary representation ` ` ` `binary ` `=` `""; ` ` ` ` ` `# Convert the octal to binary ` ` ` `for` `i ` `in` `range` `(` `len` `(s)) : ` ` ` `binary ` `+` `=` `bin` `[` `ord` `(s[i]) ` `-` `ord` `(` `'0'` `)]; ` ` ` ` ` `# Remove the LSB ` ` ` `binary ` `=` `binary[` `0` `: ` `len` `(binary) ` `-` `1` `]; ` ` ` ` ` `count ` `=` `1` `; prev ` `=` `-` `1` `;j ` `=` `0` `; ` ` ` ` ` `for` `i ` `in` `range` `(` `len` `(binary) ` `-` `1` `, ` `-` `1` `, ` `-` `1` `) : ` ` ` ` ` `# If there is 1 in the binary representation ` ` ` `if` `(binary[i] ` `=` `=` `'1'` `) : ` ` ` ` ` `# Find the number of zeroes in between ` ` ` `# two 1's in the binary representation ` ` ` `count ` `=` `max` `(count, j ` `-` `prev); ` ` ` `prev ` `=` `j; ` ` ` ` ` `j ` `+` `=` `1` `; ` ` ` ` ` `return` `count; ` ` ` `# Driver code ` `if` `__name__ ` `=` `=` `"__main__"` `: ` ` ` ` ` `octal ` `=` `"13"` `; ` ` ` ` ` `print` `(maxFreq(octal)); ` ` ` `# This code is contributed by AnkitRai01 ` |

*chevron_right*

*filter_none*

## C#

`// C# implementation of the approach ` `using` `System; ` ` ` `class` `GFG ` `{ ` ` ` `// Binary representation of the digits ` `static` `String []bin = { ` `"000"` `, ` `"001"` `, ` `"010"` `, ` `"011"` `, ` ` ` `"100"` `, ` `"101"` `, ` `"110"` `, ` `"111"` `}; ` ` ` `// Function to return the maximum frequency ` `// of s modulo with a power of 2 ` `static` `int` `maxFreq(String s) ` `{ ` ` ` ` ` `// Store the binary representation ` ` ` `String binary = ` `""` `; ` ` ` ` ` `// Convert the octal to binary ` ` ` `for` `(` `int` `K = 0; K < s.Length; K++) ` ` ` `{ ` ` ` `binary += bin[s[K] - ` `'0'` `]; ` ` ` `} ` ` ` ` ` `// Remove the LSB ` ` ` `binary = binary.Substring(0, ` ` ` `binary.Length - 1); ` ` ` ` ` `int` `count = 1, prev = -1, i, j = 0; ` ` ` ` ` `for` `(i = binary.Length - 1; ` ` ` `i >= 0; i--, j++) ` ` ` ` ` `// If there is 1 in the binary representation ` ` ` `if` `(binary[i] == ` `'1'` `) ` ` ` `{ ` ` ` ` ` `// Find the number of zeroes in between ` ` ` `// two 1's in the binary representation ` ` ` `count = Math.Max(count, j - prev); ` ` ` `prev = j; ` ` ` `} ` ` ` `return` `count; ` `} ` ` ` `// Driver code ` `public` `static` `void` `Main(String []args) ` `{ ` ` ` `String octal = ` `"13"` `; ` ` ` ` ` `Console.WriteLine(maxFreq(octal)); ` `} ` `} ` ` ` `// This code is contributed by 29AjayKumar ` |

*chevron_right*

*filter_none*

**Output:**

2

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.

## Recommended Posts:

- Chinese Remainder Theorem | Set 2 (Inverse Modulo based Implementation)
- Program to find remainder without using modulo or % operator
- Check if frequency of character in one string is a factor or multiple of frequency of same character in other string
- Count of Binary Strings of length N such that frequency of 1's exceeds frequency of 0's
- Find permutation with maximum remainder Sum
- Maximum subarray sum modulo m
- Maximum count of values of S modulo M lying in a range [L, R] after performing given operations on the array
- Chinese Remainder Theorem | Set 1 (Introduction)
- Remainder with 7 for large numbers
- Using Chinese Remainder Theorem to Combine Modular equations
- Program for quotient and remainder of big number
- Program to find remainder when large number is divided by 11
- Largest number by which given 3 numbers should be divided such that they leaves same remainder
- Quotient and remainder dividing by 2^k (a power of 2)
- Program to find remainder when large number is divided by r
- Quotient - Remainder Sort
- Minimum integer such that it leaves a remainder 1 on dividing with any element from the range [2, N]
- Minimum number of operations on a binary string such that it gives 10^A as remainder when divided by 10^B
- Find the remainder when First digit of a number is divided by its Last digit
- Count of integers obtained by replacing ? in the given string that give remainder 5 when divided by 13

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.