Open In App

Maximum frequency of a remainder modulo 2i

Last Updated : 16 Sep, 2023
Improve
Improve
Like Article
Like
Save
Share
Report

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 <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;
}


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




<script>
 
// Javascript 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
function maxFreq( s )
{
 
    // Store the binary representation
    var binary = "";
 
    // Convert the octal to binary
    for (var i = 0; i < s.length; i++) {
        binary += bin[s.charAt(i) - '0'];
    }
 
    // Remove the LSB
    binary = binary.substr(0, binary.length - 1);
 
    var 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;
}
 
var octal = "13";
document.write( maxFreq(octal));
 
// This code is contributed by SoumikMondal
 
</script>


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 <bits/stdc++.h>
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.



Like Article
Suggest improvement
Previous
Next
Share your thoughts in the comments

Similar Reads