Skip to content
Related Articles

Related Articles

Improve Article

Generate a sequence from first X natural numbers which adds up to S on raising 2 to the power of their lowest set bits

  • Last Updated : 10 Jun, 2021

Given two integers X and S, the task is to construct a sequence of distinct integers from the range [1, X] such that the sum of value 2K is equal to S, where K is the position of the first set bit from the end ( 0-based indexing )of the binary representation of each element is S.

Examples:

Input: X = 3, S = 4
Output: 2 3 1
Explanation:
Summation of 2 for every element in the set is as follows:
For 2, it is 2^1 = 2.
For 3, it is 2^0 = 1.
For 1, it is 2^0 = 1.
Therefore, the required sum = 2 + 1 + 1 = 4, which is equal to S.

Input: X = 1, S = 5
Output: -1

Approach: The problem can be solved using a Greedy Approach. Follow the steps below to solve the problem:



  • Initialize a variable, say lowBit, to store the value of 2K for any number, where K is the position of the first set bit from the end of the binary representation of each element.
  • Insert all values of lowBit for all the numbers in the range [1, X] in a vector of pairs V to pair the numbers along with their lowBit values. The value of lowBit(X) can be obtained by log2(N & -N) + 1.
  • Sort the vector in the reverse order to get the maximum lowBit at first.
  • Initialize an array, say ans[], to store the required set and an integer, say ansSum, to store the current summation of lowBit values.
  • Traverse the vector V and perform the following steps:
    • Check if (ansSum+v[i].first) <= S, then add the value of v[i].second to the array ans[] and update ansSum.
    • If ansSum is equal to the given sum S, then break from the loop and print the resultant array ans[] as the result.
  • If the ansSum is not found to be equal to S, then print “-1”.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate the lowest
// set bit of any number N
int lowBit(int N)
{
    return log2(N & -N) + 1;
}
 
// Function to generate the sequence
// which adds up to sum on raising 2
// to the power of lowest set bit
// of all integers from the sequence
void find_set(int X, int sum)
{
    // Stores the lowBit value
    vector<pair<int, int> > v;
 
    // Traverse through 1 to X and
    // insert all the lowBit value
    for (int i = 1; i <= X; i++) {
        pair<int, int> aux;
        aux.first = lowBit(i);
        aux.second = i;
        v.push_back(aux);
    }
 
    // Sort vector in reverse manner
    sort(v.rbegin(), v.rend());
 
    bool check = false;
 
    // Store all our set values
    vector<int> ans;
 
    // Stores the current
    // summation of lowBit
    int ansSum = 0;
 
    // Traverse vector v
    for (int i = 0; i < v.size(); i++) {
 
        // Check if ansSum+v[i].first
        // is at most sum
        if (ansSum + v[i].first <= sum) {
 
            // Add to the ansSum
            ansSum += v[i].first;
            ans.push_back(v[i].second);
        }
 
        // If ansSum is same as the sum,
        // then break from loop
        if (ansSum == sum) {
            check = true;
            break;
        }
    }
 
    // If check is false, no such
    // sequence can be obtained
    if (!check) {
        cout << "-1";
        return;
    }
 
    // Otherwise, print the sequence
    for (int i = 0; i < ans.size(); i++) {
        cout << ans[i] << " ";
    }
}
 
// Driver Code
int main()
{
    int X = 3, S = 4;
 
    // Generate and print
    // the required sequence
    find_set(X, S);
 
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
import java.util.*;
 
// User defined Pair class
class Pair {
  int x;
  int y;
 
  // Constructor
  public Pair(int x, int y)
  {
    this.x = x;
    this.y = y;
  }
}
 
// class to define user defined conparator
class Compare
{
  static void compare(Pair arr[], int n)
  {
 
    // Comparator to sort the pair according to second element
    Arrays.sort(arr, new Comparator<Pair>() {
      @Override public int compare(Pair p1, Pair p2)
      {
        return p1.x - p2.x;
      }
    });
  }
}
 
// Driver class
class GFG
{
 
  // Function to calculate the lowest
  // set bit of any number N
  static int lowBit(int N)
  {
    return (int)(Math.log(N & -N) / Math.log(2)) + 1;
  }
 
  // Function to generate the sequence
  // which adds up to sum on raising 2
  // to the power of lowest set bit
  // of all integers from the sequence
  static void find_set(int X, int sum)
  {
    // Stores the lowBit value
    Pair v[] = new Pair[X];
 
    // Traverse through 1 to X and
    // insert all the lowBit value
    for (int i = 0; i < X; i++)
    {
      Pair aux = new Pair(lowBit(i + 1), i + 1);
      v[i] = aux;
    }
 
    // Sort vector in reverse manner
    Compare obj = new Compare();
    obj.compare(v, X);
    int j = X - 1;
    for(int i = 0; i < X / 2; i++)
    {
      Pair temp = v[i];
      v[i] = v[j];
      v[j] = temp;
      j--;
    }
 
    boolean check = false;
 
    // Store all our set values
    Vector<Integer> ans = new Vector<Integer>();
 
    // Stores the current
    // summation of lowBit
    int ansSum = 0;
 
    // Traverse vector v
    for (int i = 0; i < X; i++) {
 
      // Check if ansSum+v[i].first
      // is at most sum
      if (ansSum + v[i].x <= sum) {
 
        // Add to the ansSum
        ansSum += v[i].x;
        ans.add(v[i].y);
      }
 
      // If ansSum is same as the sum,
      // then break from loop
      if (ansSum == sum) {
        check = true;
        break;
      }
    }
 
    // If check is false, no such
    // sequence can be obtained
    if (!check)
    {
      System.out.println("-1");
      return;
    }
 
    // Otherwise, print the sequence
    for (int i = 0; i < ans.size(); i++)
    {
      System.out.print(ans.get(i) + " ");
    }
  }
 
  // Driver code
  public static void main(String[] args)
  {
    int X = 3, S = 4;
 
    // Generate and print
    // the required sequence
    find_set(X, S);
  }
}
 
// This code is contributed by divyeshrabadiya07

Python3




# Python3 program for the above approach
from math import log2, ceil, floor
 
# Function to calculate the lowest
# set bit of any number N
def lowBit(N):
     
    return log2(N & -N) + 1
 
# Function to generate the sequence
# which adds up to sum on raising 2
# to the power of lowest set bit
# of all integers from the sequence
def find_set(X, sum):
     
    # Stores the lowBit value
    v = []
 
    # Traverse through 1 to X and
    # insert all the lowBit value
    for i in range(1, X + 1):
        aux = [0, 0]
        aux[0] = lowBit(i)
        aux[1] = i
        v.append(aux)
 
    # Sort vector in reverse manner
    v = sorted(v)[::-1]
 
    check = False
 
    # Store all our set values
    ans = []
 
    # Stores the current
    # summation of lowBit
    ansSum = 0
 
    # Traverse vector v
    for i in range(len(v)):
         
        # Check if ansSum+v[i][0]
        # is at most sum
        if (ansSum + v[i][0] <= sum):
 
            # Add to the ansSum
            ansSum += v[i][0]
            ans.append(v[i][1])
 
        # If ansSum is same as the sum,
        # then break from loop
        if (ansSum == sum):
            check = True
            break
 
    # If check is false, no such
    # sequence can be obtained
    if (not check):
        print("-1")
        return
 
    # Otherwise, print the sequence
    for i in range(len(ans)):
        print(ans[i], end = " ")
 
# Driver Code
if __name__ == '__main__':
     
    X, S = 3, 4
 
    # Generate and pr
    # the required sequence
    find_set(X, S)
 
# This code is contributed by mohit kumar 29

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG {
     
    // Function to calculate the lowest
    // set bit of any number N
    static int lowBit(int N)
    {
        return (int)(Math.Log(N & -N, 2)) + 1;
    }
      
    // Function to generate the sequence
    // which adds up to sum on raising 2
    // to the power of lowest set bit
    // of all integers from the sequence
    static void find_set(int X, int sum)
    {
        // Stores the lowBit value
        List<Tuple<int, int>> v = new List<Tuple<int, int>>();
      
        // Traverse through 1 to X and
        // insert all the lowBit value
        for (int i = 1; i <= X; i++) {
            Tuple<int, int> aux = new Tuple<int, int>(lowBit(i), i);
            v.Add(aux);
        }
      
        // Sort vector in reverse manner
        v.Sort();
        v.Reverse(); 
      
        bool check = false;
      
        // Store all our set values
        List<int> ans = new List<int>();
      
        // Stores the current
        // summation of lowBit
        int ansSum = 0;
      
        // Traverse vector v
        for (int i = 0; i < v.Count; i++) {
      
            // Check if ansSum+v[i].first
            // is at most sum
            if (ansSum + v[i].Item1 <= sum) {
      
                // Add to the ansSum
                ansSum += v[i].Item1;
                ans.Add(v[i].Item2);
            }
      
            // If ansSum is same as the sum,
            // then break from loop
            if (ansSum == sum) {
                check = true;
                break;
            }
        }
      
        // If check is false, no such
        // sequence can be obtained
        if (!check) {
            Console.Write("-1");
            return;
        }
      
        // Otherwise, print the sequence
        for (int i = 0; i < ans.Count; i++) {
            Console.Write(ans[i] + " ");
        }
    }
 
  // Driver code
  static void Main()
  {    
    int X = 3, S = 4;
  
    // Generate and print
    // the required sequence
    find_set(X, S);
  }
}
 
// This code is contributed by divyesh072019

Javascript




<script>
// Javascript program for the above approach
 
// Function to calculate the lowest
// set bit of any number N
function lowBit(N) {
    return Math.log2(N & -N) + 1;
}
 
// Function to generate the sequence
// which adds up to sum on raising 2
// to the power of lowest set bit
// of all integers from the sequence
function find_set(X, sum) {
    // Stores the lowBit value
    let v = [];
 
    // Traverse through 1 to X and
    // insert all the lowBit value
    for (let i = 1; i <= X; i++) {
        let aux = [];
        aux[0] = lowBit(i);
        aux[1] = i;
        v.push(aux);
    }
 
    // Sort vector in reverse manner
    v.sort((a, b) => a[0] - b[0]).reverse();
 
    let check = false;
 
    // Store all our set values
    let ans = [];
 
    // Stores the current
    // summation of lowBit
    let ansSum = 0;
 
    // Traverse vector v
    for (let i = 0; i < v.length; i++) {
 
        // Check if ansSum+v[i][0]
        // is at most sum
        if (ansSum + v[i][0] <= sum) {
 
            // Add to the ansSum
            ansSum += v[i][0];
            ans.push(v[i][1]);
        }
 
        // If ansSum is same as the sum,
        // then break from loop
        if (ansSum == sum) {
            check = true;
            break;
        }
    }
 
    // If check is false, no such
    // sequence can be obtained
    if (!check) {
        document.write("-1");
        return;
    }
 
    // Otherwise, print the sequence
    for (let i = 0; i < ans.length; i++) {
        document.write(ans[i] + " ");
    }
}
 
// Driver Code
 
let X = 3, S = 4;
 
// Generate and print
// the required sequence
find_set(X, S);
 
 
// This code is contributed by _saurabh_jaiswal
</script>
Output: 
2 3 1

 

Time Complexity: O(X)
Auxiliary Space: O(X)

 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :