Open In App

Modify array by right shifting digits of array elements to values exceeding K

Last Updated : 14 Aug, 2021
Comments
Improve
Suggest changes
Like Article
Like
Report

Given an array arr[] of size N and an integer K, the task is to make all array elements > K by performing right shift operations on array elements.
Note: If it is not possible to make all array elements > K, then print -1.

Examples:

Input: arr[] = { 21, 22, 23, 19 }, K = 24
Output: { 26, 26, 27, 25 }
Explanation: 
arr[0] = 10101. Performing 1 right shift -→ 11010 → 26
arr[1] = 10110. Performing 3 right shift → 11010 → 26
arr[2] = 10111. Performing 1 right shift → 11011 → 27
arr[3] = 10011. Performing 2 right shift → 11001 → 25

Input: arr[] = { 45, 37, 54, 46, 62 }, K = 48
Output: { 54, 50, 54, 53, 62 }

 

Approach: Follow the steps below to solve the problem :

  1. Traverse the array
  2. Perform right shift operation on digits of each array element arr[i].
  3. If arr[i] > k, update arr[i] and continue.
  4. If any array element arr[i] ≤ K, then print -1
  5. Otherwise, print the array arr[].

Below is the implementation of the above approach:

C++ 
// C++ program to implement
// the above approach

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

// Function to find
// MSB of a number
int setBitNumber(int n)
{

    // Stores the position of the
    // most significant set bit
    int k = log2(n);

    // Return the position of the
    // most significant set bit
    return k;
}

// Function to check if all array
// elements are exceeding k or not
bool check(int arr[], int k, int n)
{

    // Traverse the array arr
    for (int i = 0; i < n; i++) {

        // If current element
        // does not exceed k
        if (arr[i] <= k)
            return false;
    }

    return true;
}

// Function to modify array by
// right shifting digits such that
// all array elements are exceeding k
void modifyArray(int arr[], int k, int n)
{

    // Traverse the array
    for (int i = 0; i < n; i++) {

        // If current element
        // exceeds k
        if (arr[i] > k)
            continue;

        else {

            // Count bits in the binary
            // representation of arr[i]

            // MSB of arr[i]
            int bits = setBitNumber(arr[i]);

            int el = arr[i];

            // Perform right shift operations
            for (int j = 0; j < bits; j++) {

                // If the current element is odd
                if (el & 1) {

                    // Right shift the element
                    el >>= 1;

                    // Perform OR with the bitmask
                    el |= (1 << bits);
                }

                // If the current element is even
                else {

                    // Right shift the element
                    el >>= 1;
                }

                // If current element exceeds k
                if (el > k) {
                    arr[i] = el;
                    break;
                }
            }
        }
    }

    // Check if all array elements
    // are greater than k or not
    if (check(arr, k, n)) {
        for (int i = 0; i < n; i++)
            cout << arr[i] << " ";
    }
    else
        cout << -1;
}

// Driver Code
int main()
{
    int arr[] = { 21, 22, 23, 19 };

    // Size of array
    int n = sizeof(arr) / sizeof(arr[0]);

    int k = 24;

    modifyArray(arr, k, n);
    return 0;
}

// This code is contributed by subhammahato348.
Java 
// Java program to implement
// the above approach
public class GFG
{ 

  // Function to find
  // MSB of a number
  static int setBitNumber(int n)
  {

    // Stores the position of the
    // most significant set bit
    int k = (int)(Math.log(n) / Math.log(2));

    // Return the position of the
    // most significant set bit
    return k;
  }

  // Function to check if all array
  // elements are exceeding k or not
  static boolean check(int[] arr, int k, int n)
  {

    // Traverse the array arr
    for (int i = 0; i < n; i++)
    {

      // If current element
      // does not exceed k
      if (arr[i] <= k)
        return false;
    }

    return true;
  }

  // Function to modify array by
  // right shifting digits such that
  // all array elements are exceeding k
  static void modifyArray(int[] arr, int k, int n)
  {

    // Traverse the array
    for (int i = 0; i < n; i++) 
    {

      // If current element
      // exceeds k
      if (arr[i] > k)
        continue;
      else
      {

        // Count bits in the binary
        // representation of arr[i]

        // MSB of arr[i]
        int bits = setBitNumber(arr[i]);
        int el = arr[i];

        // Perform right shift operations
        for (int j = 0; j < bits; j++)
        {

          // If the current element is odd
          if ((el & 1) != 0) 
          {

            // Right shift the element
            el >>= 1;

            // Perform OR with the bitmask
            el |= (1 << bits);
          }

          // If the current element is even
          else
          {

            // Right shift the element
            el >>= 1;
          }

          // If current element exceeds k
          if (el > k) 
          {
            arr[i] = el;
            break;
          }
        }
      }
    }

    // Check if all array elements
    // are greater than k or not
    if (check(arr, k, n)) {
      for (int i = 0; i < n; i++)
        System.out.print(arr[i] + " ");
    }
    else
      System.out.print("-1");
  }

  // Driver code
  public static void main(String[] args) {
    int[] arr = { 21, 22, 23, 19 };

    // Size of array
    int n = arr.length;
    int k = 24;
    modifyArray(arr, k, n);
  }
}

// This code is conntrributed by divyesh072019.
Python3 
# Python program to implement
# the above approach
import math

# Function to find
# MSB of a number
def setBitNumber(n):

    # Stores the position of the
    # most significant set bit
    k = int(math.log(n, 2))

    # Return the position of the
    # most significant set bit
    return k

# Function to check if all array
# elements are exceeding k or not
def check(arr, k):

    # Traverse the array arr
    for el in arr:

        # If current element
        # does not exceed k
        if el <= k:
            return False
    return True

# Function to modify array by
# right shifting digits such that
# all array elements are exceeding k
def modifyArray(arr, k):

    # Traverse the array
    for i in range(len(arr)):

        # If current element
        # exceeds k
        if arr[i] > k:
            continue
        else:

            # Count bits in the binary
            # representation of arr[i]

            # MSB of arr[i]
            bits = setBitNumber(arr[i])
            el = arr[i]

            # Perform right shift operations
            for j in range(bits):

                # If the current element is odd
                if el & 1:

                    # Right shift the element
                    el >>= 1

                    # Perform OR with the bitmask
                    el |= (1 << bits)

                # If the current element is even
                else:

                    # Right shift the element
                    el >>= 1

                # If current element exceeds k
                if el > k:
                    arr[i] = el
                    break

    # Check if all array elements
    # are greater than k or not
    if check(arr, k):
        return arr
    else:
        return -1

# Driver Code

arr = [21, 22, 23, 19]
k = 24

print(modifyArray(arr, k))
C# 
// C# program to implement
// the above approach
using System;
class GFG
{

  // Function to find
  // MSB of a number
  static int setBitNumber(int n)
  {

    // Stores the position of the
    // most significant set bit
    int k = (int)(Math.Log(n, 2));

    // Return the position of the
    // most significant set bit
    return k;
  }

  // Function to check if all array
  // elements are exceeding k or not
  static bool check(int[] arr, int k, int n)
  {

    // Traverse the array arr
    for (int i = 0; i < n; i++)
    {

      // If current element
      // does not exceed k
      if (arr[i] <= k)
        return false;
    }

    return true;
  }

  // Function to modify array by
  // right shifting digits such that
  // all array elements are exceeding k
  static void modifyArray(int[] arr, int k, int n)
  {

    // Traverse the array
    for (int i = 0; i < n; i++) 
    {

      // If current element
      // exceeds k
      if (arr[i] > k)
        continue;
      else
      {

        // Count bits in the binary
        // representation of arr[i]

        // MSB of arr[i]
        int bits = setBitNumber(arr[i]);
        int el = arr[i];

        // Perform right shift operations
        for (int j = 0; j < bits; j++)
        {

          // If the current element is odd
          if ((el & 1) != 0) 
          {

            // Right shift the element
            el >>= 1;

            // Perform OR with the bitmask
            el |= (1 << bits);
          }

          // If the current element is even
          else 
          {

            // Right shift the element
            el >>= 1;
          }

          // If current element exceeds k
          if (el > k) 
          {
            arr[i] = el;
            break;
          }
        }
      }
    }

    // Check if all array elements
    // are greater than k or not
    if (check(arr, k, n)) {
      for (int i = 0; i < n; i++)
        Console.Write(arr[i] + " ");
    }
    else
      Console.Write("-1");
  }

  // Driver Code
  public static void Main()
  {
    int[] arr = { 21, 22, 23, 19 };

    // Size of array
    int n = arr.Length;
    int k = 24;
    modifyArray(arr, k, n);
  }
}

// This code is contributed by chitranayal.
JavaScript 
<script>
// Javascript program to implement
// the above approach

// Function to find
// MSB of a number
function setBitNumber(n)
{

    // Stores the position of the
    // most significant set bit
    let k = Math.log2(n);

    // Return the position of the
    // most significant set bit
    return k;
}

// Function to check if all array
// elements are exceeding k or not
function check(arr, k, n)
{

    // Traverse the array arr
    for (let i = 0; i < n; i++)
    {

        // If current element
        // does not exceed k
        if (arr[i] <= k)
            return false;
    }
    return true;
}

// Function to modify array by
// right shifting digits such that
// all array elements are exceeding k
function modifyArray(arr, k, n)
{

    // Traverse the array
    for (let i = 0; i < n; i++)
    {

        // If current element
        // exceeds k
        if (arr[i] > k)
            continue;

        else 
        {

            // Count bits in the binary
            // representation of arr[i]

            // MSB of arr[i]
            let bits = setBitNumber(arr[i]);
            let el = arr[i];

            // Perform right shift operations
            for (let j = 0; j < bits; j++) 
            {

                // If the current element is odd
                if (el & 1) 
                {

                    // Right shift the element
                    el >>= 1;

                    // Perform OR with the bitmask
                    el |= (1 << bits);
                }

                // If the current element is even
                else 
                {

                    // Right shift the element
                    el >>= 1;
                }

                // If current element exceeds k
                if (el > k)
                {
                    arr[i] = el;
                    break;
                }
            }
        }
    }

    // Check if all array elements
    // are greater than k or not
    if (check(arr, k, n))
    {
        for (let i = 0; i < n; i++)
            document.write(arr[i] + " ");
    }
    else
        document.write(-1);
}

// Driver Code
let arr = [ 21, 22, 23, 19 ];

// Size of array
let n = arr.length;
let k = 24;
modifyArray(arr, k, n);

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

Output: 
[26, 26, 27, 25]

 

Time Complexity: O(N)
Auxiliary Space: O(1)


Next Article
Must Do Coding Questions Company-wise
author
rohitsingh07052
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox