Open In App

# Maximum frequency of a remainder modulo 2i

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. 2i such that i > 0 and 2i < N, and print the maximum frequency of the modulo.
Examples:

Input: N = 13
Output:
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:

Approach: Find the binary representation of the number by replacing the digit with its 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 ``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;``}`

## 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`

## 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`

## 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`

## Javascript

 ``

Output

```2

```

Time Complexity: O(N), as we are using a loop to traverse N times. Where N is the length of the string.
Auxiliary Space: O(N), as we are using extra space for the string binary.

Approach:

One simple way is to convert the octal number to decimal and then calculate the modulo with every power of 2 until 2i becomes greater than or equal to the decimal value. We can use an array to store the frequency of each modulo and then find the maximum frequency.

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `// Function to convert an octal string to decimal``int` `octalToDecimal(string octal)``{``    ``int` `decimal = 0, power = 1;``    ``for` `(``int` `i = octal.length() - 1; i >= 0; i--) {``        ``decimal += (octal[i] - ``'0'``) * power;``        ``power *= 8;``    ``}``    ``return` `decimal;``}` `// Function to find the maximum frequency of modulo with a``// power of 2``int` `maxFreq(string octal)``{``    ``int` `decimal = octalToDecimal(octal);``    ``int` `freq[32]``        ``= { 0 }; ``// Array to store the frequency of modulos``    ``for` `(``int` `i = 1; i <= log2(decimal); i++) {``        ``int` `rem = decimal % (1 << i);``        ``freq[rem]++;``    ``}``    ``int` `maxFreq = 0, iMax = 0;``    ``for` `(``int` `i = 0; i <= log2(decimal); i++) {``        ``if` `(freq[i] > maxFreq) {``            ``maxFreq = freq[i];``            ``iMax = i;``        ``}``    ``}``    ``return` `maxFreq;``}` `// Driver code``int` `main()``{``    ``string octal = ``"13"``;``    ``cout << maxFreq(octal);``    ``return` `0;``}`

## Java

 `import` `java.util.Arrays;` `public` `class` `GFG {` `    ``// Function to convert an octal string to decimal``    ``public` `static` `int` `octalToDecimal(String octal)``    ``{``        ``int` `decimal = ``0``, power = ``1``;``        ``for` `(``int` `i = octal.length() - ``1``; i >= ``0``; i--) {``            ``decimal += (octal.charAt(i) - ``'0'``) * power;``            ``power *= ``8``;``        ``}``        ``return` `decimal;``    ``}` `    ``// Function to find the maximum frequency of modulo with``    ``// a power of 2``    ``public` `static` `int` `maxFreq(String octal)``    ``{``        ``int` `decimal = octalToDecimal(octal);``        ``int``[] freq = ``new` `int``[``32``]; ``// Array to store the``                                  ``// frequency of modulos``        ``Arrays.fill(freq, ``0``);` `        ``for` `(``int` `i = ``1``;``             ``i <= Math.log(decimal) / Math.log(``2``); i++) {``            ``int` `rem = decimal % (``1` `<< i);``            ``freq[rem]++;``        ``}` `        ``int` `maxFreq = ``0``, iMax = ``0``;``        ``for` `(``int` `i = ``0``;``             ``i <= Math.log(decimal) / Math.log(``2``); i++) {``            ``if` `(freq[i] > maxFreq) {``                ``maxFreq = freq[i];``                ``iMax = i;``            ``}``        ``}``        ``return` `maxFreq;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String octal = ``"13"``;``        ``System.out.println(maxFreq(octal));``    ``}``}`

## Python

 `import` `math` `# Function to convert an octal string to decimal`  `def` `octal_to_decimal(octal):``    ``decimal_num ``=` `0``    ``power ``=` `1``    ``for` `i ``in` `range``(``len``(octal) ``-` `1``, ``-``1``, ``-``1``):``        ``decimal_num ``+``=` `int``(octal[i]) ``*` `power``        ``power ``*``=` `8``    ``return` `decimal_num` `# Function to find the maximum frequency of modulo with a power of 2`  `def` `max_freq(octal):``    ``decimal_num ``=` `octal_to_decimal(octal)``    ``freq ``=` `[``0``] ``*` `32`  `# Array to store the frequency of modulos``    ``for` `i ``in` `range``(``1``, ``int``(math.log(decimal_num, ``2``)) ``+` `1``):``        ``rem ``=` `decimal_num ``%` `(``1` `<< i)``        ``freq[rem] ``+``=` `1``    ``max_freq ``=` `0``    ``i_max ``=` `0``    ``for` `i ``in` `range``(``int``(math.log(decimal_num, ``2``)) ``+` `1``):``        ``if` `freq[i] > max_freq:``            ``max_freq ``=` `freq[i]``            ``i_max ``=` `i``    ``return` `max_freq`  `# Driver code``if` `__name__ ``=``=` `"__main__"``:``    ``octal ``=` `"13"``    ``print``(max_freq(octal))`

## C#

 `using` `System;` `class` `Program {``    ``// Function to convert an octal string to decimal``    ``static` `int` `OctalToDecimal(``string` `octal)``    ``{``        ``int` `decimalNum = 0;``        ``int` `power = 1;``        ``for` `(``int` `i = octal.Length - 1; i >= 0; i--) {``            ``decimalNum += (octal[i] - ``'0'``) * power;``            ``power *= 8;``        ``}``        ``return` `decimalNum;``    ``}` `    ``// Function to find the maximum frequency of modulo with``    ``// a power of 2``    ``static` `int` `MaxFreq(``string` `octal)``    ``{``        ``int` `decimalNum = OctalToDecimal(octal);``        ``int``[] freq = ``new` `int``[32]; ``// Array to store the``                                  ``// frequency of modulos``        ``for` `(``int` `i = 1;``             ``i <= (``int``)(Math.Log(decimalNum) / Math.Log(2));``             ``i++) {``            ``int` `rem = decimalNum % (1 << i);``            ``freq[rem]++;``        ``}``        ``int` `maxFreq = 0;``        ``int` `iMax = 0;``        ``for` `(``int` `i = 0;``             ``i <= (``int``)(Math.Log(decimalNum) / Math.Log(2));``             ``i++) {``            ``if` `(freq[i] > maxFreq) {``                ``maxFreq = freq[i];``                ``iMax = i;``            ``}``        ``}``        ``Console.WriteLine(``"Max frequency: "` `+ maxFreq);``        ``Console.WriteLine(``"iMax: "` `+ iMax);``        ``return` `maxFreq;``    ``}` `    ``// Driver code``    ``static` `void` `Main()``    ``{``        ``string` `octal = ``"13"``;``        ``Console.WriteLine(MaxFreq(octal));``    ``}``}`

## Javascript

 `// Function to convert an octal string to decimal``function` `octalToDecimal(octal) {``    ``let decimal = 0;``    ``let power = 1;``    ``for` `(let i = octal.length - 1; i >= 0; i--) {``        ``decimal += (parseInt(octal[i], 10)) * power;``        ``power *= 8;``    ``}``    ``return` `decimal;``}` `// Function to find the maximum frequency of modulo with a``// power of 2``function` `maxFreq(octal) {``    ``let decimal = octalToDecimal(octal);``    ``let freq = ``new` `Array(32).fill(0); ``// Array to store the frequency of modulos``    ``for` `(let i = 1; i <= Math.log2(decimal); i++) {``        ``let rem = decimal % (1 << i);``        ``freq[rem]++;``    ``}``    ``let maxFreq = 0;``    ``let iMax = 0;``    ``for` `(let i = 0; i <= Math.log2(decimal); i++) {``        ``if` `(freq[i] > maxFreq) {``            ``maxFreq = freq[i];``            ``iMax = i;``        ``}``    ``}``    ``return` `maxFreq;``}` `// Driver code``let octal = ``"13"``;``console.log(maxFreq(octal));`

Output

```2

```

Time Complexity: O(log n), where n is the decimal equivalent of the given octal number. The loop runs for log2(n) times to calculate the modulos with powers of 2.
Auxiliary Space: O(log n), where n is the decimal equivalent of the given octal number. This is because we need to store the frequency of modulos in an array of size log2(n) + 1.