Minimize product of first N – 1 natural numbers by swapping same positioned bits of pairs

Given an integer N, the task is to find the minimum positive product of first N – 1 natural numbers, i.e. [1, (N – 1)], by swapping any i^th bit of any two numbers any number of times.

Note: N is always a perfect power of 2. Since the product can be very large, print the answer modulo 10⁹ + 7.

Examples:

Input: N = 4
Output: 6
Explanation:
No swapping of bits is required. Therefore, the minimum product is 1*2*3 = 6.

Input: N = 8
Output: 1512
Explanation:
Let the array arr[] stores all the value from 1 to N as {1, 2, 3, 4, 5, 6, 7}
Follow the below steps:
Step 1: In elements 2 = (0010) and 5 = (0101), swap 0th and 1st bit. Therefore, replace 2 with 1 and 5 with 6. arr[] = {1, 1, 3, 4, 6, 6, 7}.
Step 2: In elements 3 = (0011) and 4 = (0100), swap 1th bit. Therefore, replace 3 with 1 and 4 with 6. arr[] = {1, 1, 1, 6, 6, 6, 7}.
Hence, the minimum product = 1*1*1*6*6*6*7 = 1512 % 1e9+7 = 1512.

Approach: The idea is to make some observations. For example, if N = 8 and arr[] = {1, 2, 3, 4, 5, 6, 7}, observe that for the product to be minimum there must be three sixes i.e., there must be an element having value (N – 2) with the frequency of occurrence as (1 + (N – 4)/2) and there must be three ones i.e., there must be (1 + (N – 4)/2) ones. And at last multiply the current product with (N – 1). Hence, the formula becomes:

Minimum product for any value N = ((N – 1) * (N – 2)^{(N – 4)/2 + 1}) % 1e9 + 7 

Follow the below steps to solve the problem:

1. Initialize the ans as 1.
2. Iterate over the range [0, 1 + (N – 4)/2].
3. In each traversal, multiply ans with N – 2 and update the ans to ans mod 1e9+7.
4. After the above steps, print the value of ans*(N – 1) mod 1e9+7 as the result.

Below is the implementation of the above approach:

C++

// C++ program for the above approach

#include <bits/stdc++.h>
using namespace std;

int mod = 1e9 + 7;

// Function to find the minimum product
// of 1 to N - 1 after performing the
// given operations
void minProduct(int n)
{
    // Initialize ans with 1
    int ans = 1;

    // Multiply ans with N-2
    // ((N - 4)/2) times
    for (int i = 1;
         i <= (n - 4) / 2; i++) {
        ans = (1LL * ans
               * (n - 2))
              % mod;
    }

    // Multiply ans with N - 1
    // and N - 2 once
    ans = (1LL * ans
           * (n - 2) * (n - 1))
          % mod;

    // Print ans
    cout << ans << endl;
}

// Driver Code
int main()
{
    // Given Number N
    int N = 8;

    // Function Call
    minProduct(N);

    return 0;
}

Java

// Java program for the
// above approach
import java.util.*;
class GFG{

static int mod = (int)1e9 + 7;

// Function to find the
// minimum product of 1
// to N - 1 after performing
// the given operations
static void minProduct(int n)
{
  // Initialize ans with 1
  int ans = 1;

  // Multiply ans with N-2
  // ((N - 4)/2) times
  for (int i = 1;
           i <= (n - 4) / 2; i++)
  {
    ans = (int)(1L * ans *
               (n - 2)) % mod;
  }

  // Multiply ans with N - 1
  // and N - 2 once
  ans = (int)(1L * ans *
             (n - 2) * (n - 1)) % mod;

  // Print ans
  System.out.print(ans + "\n");
}

// Driver Code
public static void main(String[] args)
{
  // Given Number N
  int N = 8;

  // Function Call
  minProduct(N);
}
}

// This code is contributed by gauravrajput1

Python3

# Python3 program for the above approach
mod = 1e9 + 7

# Function to find the minimum product
# of 1 to N - 1 after performing the
# given operations
def minProduct(n):

    # Initialize ans with 1
    ans = 1

    # Multiply ans with N-2
    # ((N - 4)/2) times
    for i in range(1, (n - 4) // 2 + 1):
        ans = (ans * (n - 2)) % mod

    # Multiply ans with N - 1
    # and N - 2 once
    ans = (ans * (n - 2) * (n - 1)) % mod

    # Print ans
    print(int(ans))

# Driver Code
if __name__ == '__main__':

    # Given number N
    N = 8

    # Function call
    minProduct(N)

# This code is contributed by mohit kumar 29

C#

// C# program for the
// above approach
using System;
class GFG{

static int mod = (int)1e9 + 7;

// Function to find the
// minimum product of 1
// to N - 1 after performing
// the given operations
static void minProduct(int n)
{
  // Initialize ans with 1
  int ans = 1;

  // Multiply ans with N-2
  // ((N - 4)/2) times
  for (int i = 1;
           i <= (n - 4) / 2; i++)
  {
    ans = (int)(1L * ans *
               (n - 2)) % mod;
  }

  // Multiply ans with N - 1
  // and N - 2 once
  ans = (int)(1L * ans *
             (n - 2) *
             (n - 1)) % mod;

  // Print ans
  Console.Write(ans + "\n");
}

// Driver Code
public static void Main(String[] args)
{
  // Given Number N
  int N = 8;

  // Function Call
  minProduct(N);
}
}

// This code is contributed by Rajput-Ji

Javascript

<script>
// JavaScript program for the above approach

let mod = 1e9 + 7;

// Function to find the minimum product
// of 1 to N - 1 after performing the
// given operations
function minProduct(n)
{
    // Initialize ans with 1
    let ans = 1;

    // Multiply ans with N-2
    // ((N - 4)/2) times
    for (let i = 1; i <= Math.floor((n - 4) / 2); i++)
    {
        ans = (1 * ans * (n - 2)) % mod;
    }

    // Multiply ans with N - 1
    // and N - 2 once
    ans = (1 * ans * (n - 2) * (n - 1)) % mod;

    // Print ans
    document.write(ans + "<br>");
}

// Driver Code

    // Given Number N
    let N = 8;

    // Function Call
    minProduct(N);

// This code is contributed by Manoj.
</script>

Output

1512

Time Complexity: O(N) where N is the given integer.
Auxiliary Space: O(1)