Skip to content
Related Articles

Related Articles

Number from a range [L, R] having Kth minimum cost of conversion to 1 by given operations
  • Last Updated : 14 Dec, 2020

Given three integers L, R and K where [L, R] denotes the range of elements, the task is to find the element in the range [L, R] requiring Kth minimum cost of conversion to 1. If two or more elements have the same cost, then print the minimum among them. 

Cost of conversion of an element X to 1 using the given operations is the count of operations used: 

  1. If X is even, then convert X to X/2
  2. If X is odd, then convert X to 3*X + 1

Examples: 

Input: L = 12, R = 15, K = 2 
Output: 13 
Explanation: 
The cost associated with 12 is 9 (12 –> 6 –> 3 –> 10 –> 5 –> 16 –> 8 –> 4 –> 2 –> 1) 
The cost associated with 13 is 9 (13 –> 40 –> 20 –> 10 –> 5 –> 16 –> 8 –> 4 –> 2 –> 1) 
The cost associated with 14 is 17 (14 –> 7 –> 22 –> 11 –> 34 –> 17 –> 52 –> 26 –> 13 –> 40 –> 20 –> 10 –> 5 –> 16 –> 8 –> 4 –> 2 –> 1) 
The cost associated with 15 is 17 (15 –> 46–> 23 –> 70 –> 35 –> 106 –> 53 –> 160 –> 80 –> 40 –> 20 –> 10 –> 5 –> 16 –> 8 –> 4 –> 2 –> 1) 
The element sorted according to cost is [12, 13, 14, 15]. 
For K = 2, the output is 13.

Input: L = 1, R = 1, K = 1 
Output: 1



Naive Approach: The simplest approach is to calculate the cost associated with each element between L and R using recursion. Below are the steps: 

  1. Define a function func which calculates the cost recursively.
  2. Store all the cost of elements in an array of pairs.
  3. Sort the array of pairs according to their cost.
  4. Then return the element at (K-1)th index from the array.

Below is the implementation of the above approach:  

C++14




// C++14 implementation of
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
//Function to calculate the cost
int func(int n)
{
    int count = 0;
 
    // Base case
    if (n == 2 or n == 1)
        return 1;
 
    // Even condtion
    if (n % 2 == 0)
        count = 1 + func(n / 2);
 
    // Odd condtion
    if (n % 2 != 0)
        count = 1 + func(n * 3 + 1);
 
    // Return cost
    return count;
}
 
// Function to find Kth element
void findKthElement(int l, int r, int k)
{
    vector<int> arr;
 
    for(int i = l; i <= r; i++)
        arr.push_back(i);
 
    // Array to store the costs
    vector<vector<int>> result;
 
    for(int i : arr)
        result.push_back({i, func(i)});
 
    // Sort the array based on cost
    sort(result.begin(), result.end());
 
    cout << (result[k - 1][0]);
}
 
// Driver Code
int main()
{
     
    // Given range and6 K
    int l = 12;
    int r = 15;
    int k = 2;
     
    // Function call
    findKthElement(l, r, k);
     
    return 0;
}
 
// This code is contributed by mohit kumar 29

Java




// Java implementation of
// the above approach
import java.util.*;
 
class GFG{
 
// Function to calculate the cost
static int func(int n)
{
    int count = 0;
 
    // Base case
    if (n == 2 || n == 1)
        return 1;
 
    // Even condtion
    if (n % 2 == 0)
        count = 1 + func(n / 2);
 
    // Odd condtion
    if (n % 2 != 0)
        count = 1 + func(n * 3 + 1);
 
    // Return cost
    return count;
}
 
// Function to find Kth element
static void findKthElement(int l, int r, int k)
{
    ArrayList<Integer> arr = new ArrayList<>();
 
    for(int i = l; i <= r; i++)
        arr.add(i);
 
    // Array to store the costs
    ArrayList<List<Integer>> result = new ArrayList<>();
 
    for(int i : arr)
        result.add(Arrays.asList(i, func(i)));
 
    // Sort the array based on cost
    Collections.sort(result, (s1, s2) -> s1.get(1) -
                                         s2.get(1));
 
    System.out.println(result.get(k - 1).get(0));
}
 
// Driver code
public static void main (String[] args)
{
     
    // Given range and6 K
    int l = 12;
    int r = 15;
    int k = 2;
     
    // Function call
    findKthElement(l, r, k);
}
}
 
// This code is contributed by offbeat

Python3




# Python3 implementation of
# the above approach
 
# Function to calculate the cost
def func(n):
    count = 0
     
    # Base case
    if n == 2 or n == 1:
        return 1
     
    # Even condtion
    if n % 2 == 0:  
        count = 1 + func(n//2)
 
    # Odd condtion
    if n % 2 != 0
        count = 1 + func(n * 3 + 1)
 
    # Return cost 
    return count
 
# Function to find Kth element
def findKthElement(l, r, k):
    arr = list(range(l, r + 1))
 
    # Array to store the costs
    result = []
    for i in arr:
        result.append([i, func(i)])
 
    # Sort the array based on cost
    result.sort()
    print(result[k-1][0])
 
# Driver Code
 
# Given range and K
l = 12
r = 15
k = 2
 
# Function Call
findKthElement(l, r, k)

C#




// C# implementation of
// the above approach
using System;
using System.Linq;
using System.Collections.Generic;
 
class GFG{
 
// Function to calculate the cost
static int func(int n)
{
    int count = 0;
     
    // Base case
    if (n == 2 || n == 1)
        return 1;
 
    // Even condtion
    if (n % 2 == 0)
        count = 1 + func(n / 2);
 
    // Odd condtion
    if (n % 2 != 0)
        count = 1 + func(n * 3 + 1);
 
    // Return cost
    return count;
}
 
// Function to find Kth element
static void findKthElement(int l, int r, int k)
{
    List<int> arr = new List<int>();
 
    for(int i = l; i <= r; i++)
        arr.Add(i);
 
    // Array to store the costs
    Dictionary<int,
               int> result = new Dictionary<int,
                                            int>();
    foreach(int i in arr)
    {
        result.Add(i, func(i));
    }
     
    // Sort the array based on cost
    var myList = result.ToList();
     
    myList.Sort((pair1, pair2) => pair1.Value.CompareTo(
        pair2.Value));
 
    Console.WriteLine(myList[1].Key);
}
 
// Driver code
public static void Main(String[] args)
{
     
    // Given range and6 K
    int l = 12;
    int r = 15;
    int k = 2;
     
    // Function call
    findKthElement(l, r, k);
}
}
 
// This code is contributed by aashish1995
Output: 
13

 

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

Efficient approach: The above approach can be optimized by using Dynamic Programming. Below are the steps:

  • To avoid recalculating the overlapping subproblems, initialize a dp[] array to store the minimum cost to reach 1 from for every encountered subproblem.
  • The recurrence relation to update the dp[] table is :

dp[n] = 1 + func(n / 2) for even elements 
dp[n] = 1 + func(3 * n + 1) for odd elements 

  • Store all the calculated costs in an array of pairs
  • Sort the array of pairs according to their cost.
  • Then return the element at (K – 1)th index from the array.

Below is the implementation of the above approach:

C++




// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate the cost
int func(int n, int dp[])
{
    int count = 0;
 
    // Base case
    if (n == 2 || n == 1)
        return 1;
 
    if (dp[n] != -1)
        return dp[n];
 
    // Even condtion
    if (n % 2 == 0)
        count = 1 + func(n / 2, dp);
 
    // Odd condition
    if (n % 2 != 0)
        count = 1 + func(n * 3 + 1, dp);
 
    // Store the result
    dp[n] = count;
    return dp[n];
}
 
// Function to find Kth element
void findKthElement(int l, int r, int k)
{
 
    // Array to store the results
    vector<pair<int, int> > result;
 
    // Define DP array
    int dp[r + 1] = {0};
    dp[1] = 1;
    dp[2] = 1;
 
    for(int i = l; i <= r; i++)
        result.push_back({i, func(i, dp)});
 
    // Sort the array based on cost
    sort(result.begin(), result.end());
     
    cout << (result[k - 1].first);
}
 
// Driver code
int main()
{
     
    // Given range and K
    int l = 12;
    int r = 15;
    int k = 2;
 
    // Function call
    findKthElement(l, r, k);
}
 
// This code is contributed by grand_master

Java




// Java implementation of
// the above approach
import java.util.*;
class GFG{
     
static class Pair implements Comparable<Pair>
{
  int start,end;
   
  Pair(int s, int e)
  {
    start = s;
    end = e;
  }
 
  public int compareTo(Pair p)
  {
    return this.start - p.start;
  }
}
 
// Function to calculate
// the cost
static int func(int n,
                int dp[])
{
  int count = 0;
 
  // Base case
  if (n == 2 ||
      n == 1)
    return 1;
 
  if (dp[n] != -1)
    return dp[n];
 
  // Even condtion
  if (n % 2 == 0)
    count = 1 + func(n / 2, dp);
 
  // Odd condition
  if (n % 2 != 0)
    count = 1 + func(n * 3 +
                     1, dp);
 
  // Store the result
  dp[n] = count;
  return dp[n];
}
 
// Function to find Kth element
static void findKthElement(int l,
                           int r,
                           int k)
{
  // Array to store the
  // results
  Vector<Pair> result =
         new Vector<>();
 
  // Define DP array
  int []dp = new int[r + 1];
  dp[1] = 1;
  dp[2] = 1;
 
  for(int i = l; i <= r; i++)
    result.add(new Pair(i,
               func(i, dp)));
 
  // Sort the array based
  // on cost
  Collections.sort(result);
 
  System.out.print(
  result.get(k - 1).start);
}
 
// Driver code
public static void main(String[] args)
{   
  // Given range and K
  int l = 12;
  int r = 15;
  int k = 2;
 
  // Function call
  findKthElement(l, r, k);
}
}
 
// This code is contributed by gauravrajput1

Python3




# Python3 implementation of the above approach
# Function to calculate the cost
def func(n, dp):
    count = 0
 
    # Base case
    if n == 2 or n == 1:
        return 1
    if n in dp:
      return dp[n] 
 
    # Even condtion
    if n % 2 == 0
        count = 1 + func(n//2, dp)
 
    # Odd condition
    if n % 2 != 0:  
        count = 1 + func(n * 3 + 1, dp)
 
    # Store the result
    dp[n]= count
    return dp[n]
 
# Function to find Kth element
def findKthElement(l, r, k):
    arr = list(range(l, r + 1))
 
    # Array to store the results
    result = []
 
    # Define DP array
    dp ={1:1, 2:1}
 
    for i in arr:
        result.append([i, func(i, dp)])
 
    # Sort the array based on cost
    result.sort()
    print(result[k-1][0])
 
# Given range and K
l = 12
r = 15
k = 2
 
# Function Call
findKthElement(l, r, k)

C#




// C# implementation of
// the above approach
using System;
using System.Collections;
 
class GFG{
     
class Pair
{
   public int start,end;
    
  public Pair(int s, int e)
  {
    start = s;
    end = e;
  }
}
 
class sortHelper : IComparer
{
   int IComparer.Compare(object a, object b)
   {
      Pair first=(Pair)a;
      Pair second=(Pair)b;
         
      return first.start - second.start;
   }
}
      
  
// Function to calculate
// the cost
static int func(int n, int []dp)
{
  int count = 0;
  
  // Base case
  if (n == 2 || n == 1)
    return 1;
  
  if (dp[n] != -1)
    return dp[n];
  
  // Even condtion
  if (n % 2 == 0)
    count = 1 + func(n / 2, dp);
  
  // Odd condition
  if (n % 2 != 0)
    count = 1 + func(n * 3 +
                     1, dp);
  
  // Store the result
  dp[n] = count;
  return dp[n];
}
  
// Function to find Kth element
static void findKthElement(int l,
                           int r,
                           int k)
{
  // Array to store the
  // results
  ArrayList result =
         new ArrayList();
  
  // Define DP array
  int []dp = new int[r + 1];
  dp[1] = 1;
  dp[2] = 1;
  
  for(int i = l; i <= r; i++)
    result.Add(new Pair(i,
               func(i, dp)));
  
  // Sort the array based
  // on cost
  result.Sort(new sortHelper());
  
  Console.Write(((Pair)result[k - 1]).start);
}
  
// Driver code
public static void Main(string[] args)
{   
  // Given range and K
  int l = 12;
  int r = 15;
  int k = 2;
  
  // Function call
  findKthElement(l, r, k);
}
}
 
// This code is contributed by rutvik_56
Output: 
13

 

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

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 :