Check if given Array can be made a permutation of 1 to N by reducing elements by half

Given an array nums[] of size N, the task is to check whether the given array can be converted into a permutation of 1 to N after performing given operations any number of times (may be 0). An operation is defined as: Pick any element of the array say 'x', and replace it with 'x/2'.

Note: In a permutation of 1 to N all the numbers in range [1, N] are present in any order and each number is present only once.

Examples:

Input: N = 4, nums[] = {1, 8, 25, 2}
Output: true
Explanation: Sequence of operations followed are listed below:
Replace 8 with 8/2 = 4, nums[] = {1, 4, 25, 2}
Replace 25 with 25/2 = 12, nums[] = {1, 4, 12, 2}
Replace 12 with 12/2 = 6, nums[] = {1, 4, 6, 2}
Replace 6 with 6/2 = 3, nums[] = {1, 4, 3, 2} (Here element from 1 to 4 is present exactly once)

Input: N = 4, nums[] = {24, 7, 16, 7}
Output: false

Approach: The solution to the problem is based on sorting. Create an array freq of type boolean and size (N+1) to keep track of the numbers of the desired permutation. Follow the below steps:

• Sort the given array.
• Traverse from the back of the array and at each step:
  • If val is less than N and freq[val] is false then mark it as true.
  • If val is greater than N or freq[val] is true then divide it by 2 while (val > 0 && freq[val] == true)
  • At last, check if the desired permutation is achieved or not.

Below is the implementation of the above approach:

// C++ code to implement the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to check is it possible
// to make array or not
bool possibleOrNot(vector<int>& nums, int N)
{

  // Sorting array
  sort(nums.begin(), nums.end());

  // Initializing freq[] array which
  // keeps track of elements from 1 to N
  vector<bool> freq(N + 1, 0);

  // Iterating from backwards
  for (int i = N - 1; i >= 0; i--) {
    int val = nums[i];

    // Dividing val by 2 while
    // it is greater than N
    // or freq[val] is true
    while (val > N || (freq[val] && val >= 1)) {
      val /= 2;
    }

    // Updating freq array
    if (val != 0)
      freq[val] = true;
  }

  // Checking if every element from
  // 1 to N is present or not
  for (int i = 1; i < freq.size(); i++)
    if (!freq[i]) {
      return false;
    }

  return true;
}

// Driver Code
int main()
{
  int N = 4;
  vector<int> nums = { 1, 8, 25, 2 };

  bool ans = possibleOrNot(nums, N);
  cout << (ans);

  return 0;
}

  // This code is contributed by rakeshsahni

// Java code to implement the above approach
import java.util.*;

class GFG {

    // Driver Code
    public static void main(String[] args)
    {
        int N = 4;
        int[] nums = { 1, 8, 25, 2 };

        boolean ans = possibleOrNot(nums, N);
        System.out.println(ans);
    }

    // Function to check is it possible
    // to make array or not
    public static boolean possibleOrNot(int[] nums,
                                        int N)
    {
        // Sorting array
        Arrays.sort(nums);

        // Initializing freq[] array which
        // keeps track of elements from 1 to N
        boolean[] freq = new boolean[N + 1];

        // Iterating from backwards
        for (int i = N - 1; i >= 0; i--) {
            int val = nums[i];

            // Dividing val by 2 while
            // it is greater than N
            // or freq[val] is true
            while (val > N || (freq[val]
                               && val >= 1)) {
                val /= 2;
            }

            // Updating freq array
            if (val != 0)
                freq[val] = true;
        }

        // Checking if every element from
        // 1 to N is present or not
        for (int i = 1; i < freq.length; i++)
            if (!freq[i]) {
                return false;
            }

        return true;
    }
}

# python3 code to implement the above approach

# Function to check is it possible
# to make array or not
def possibleOrNot(nums, N):

    # Sorting array
    nums.sort()

    # Initializing freq[] array which
    # keeps track of elements from 1 to N
    freq = [0 for _ in range(N + 1)]

    # Iterating from backwards
    for i in range(N - 1, -1, -1):
        val = nums[i]

        # Dividing val by 2 while
        # it is greater than N
        # or freq[val] is true
        while (val > N or (freq[val] and val >= 1)):
            val //= 2

        # Updating freq array
        if (val != 0):
            freq[val] = True

    # Checking if every element from
    # 1 to N is present or not
    for i in range(1, len(freq)):
        if (not freq[i]):
            return False

    return True

# Driver Code
if __name__ == "__main__":

    N = 4
    nums = [1, 8, 25, 2]

    ans = possibleOrNot(nums, N)
    print(ans)

    # This code is contributed by rakeshsahni

using System;

public class GFG{

  // Function to check is it possible
  // to make array or not
  static bool possibleOrNot(int[] nums,
                            int N)
  {
    // Sorting array
    Array.Sort(nums);

    // Initializing freq[] array which
    // keeps track of elements from 1 to N
    bool[] freq = new bool[N + 1];

    // Iterating from backwards
    for (int i = N - 1; i >= 0; i--) {
      int val = nums[i];

      // Dividing val by 2 while
      // it is greater than N
      // or freq[val] is true
      while (val > N || (freq[val]
                         && val >= 1)) {
        val /= 2;
      }

      // Updating freq array
      if (val != 0)
        freq[val] = true;
    }

    // Checking if every element from
    // 1 to N is present or not
    for (int i = 1; i < freq.Length; i++)
      if (!freq[i]) {
        return false;
      }

    return true;
  }

  // Driver Code
  static public void Main (){

    int N = 4;
    int[] nums = { 1, 8, 25, 2 };

    bool ans = possibleOrNot(nums, N);
    if(ans == true)
      Console.WriteLine(1);
    else
      Console.WriteLine(0);
  }
}

// This code is contributed by hrithikgrg03188.

<script>
// Javascript code to implement the above approach

// Function to check is it possible
// to make array or not
function possibleOrNot(nums, N)
{

    // Sorting array
    nums.sort((a, b) => a - b);

    // Initializing freq[] array which
    // keeps track of elements from 1 to N
    let freq = new Array(N + 1).fill(0)

    // Iterating from backwards
    for (let i = N - 1; i >= 0; i--) {
        let val = nums[i];

        // Dividing val by 2 while
        // it is greater than N
        // or freq[val] is true
        while (val > N || (freq[val] && val >= 1)) {
            val = Math.floor(val / 2);
        }

        // Updating freq array
        if (val != 0)
            freq[val] = true;
    }

    // Checking if every element from
    // 1 to N is present or not
    for (let i = 1; i < freq.length; i++)
        if (!freq[i]) {
            return false;
        }

    return true;
}

// Driver Code
let N = 4;
let nums = [1, 8, 25, 2]

let ans = possibleOrNot(nums, N);
document.write(ans);

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

true

Time Complexity: O(N * log(N))
Auxiliary Space: O(N)