Skip to content
Related Articles

Related Articles

Check if permutation of N exists with product of atleast 1 subarray’s size and min as K

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Medium
  • Last Updated : 30 Mar, 2022

Given two integers N and K, the task is to check if it is possible to form a permutation of N integers such that it contains atleast 1 subarray such that the product of length of that subarray with minimum element present in it is K.

A permutation of size N have all the integers from 1 to N present in it only once.

Examples:

Input: N = 5, K = 6
Output: True
Explanation: {4, 2, 1, 3, 5} is a valid array containing integers from 1 to 5. The required subarray is {3, 5}. 
Length of subarray = 2, minimum element in subarray = 3. 
Their product = 2 x 3 = 6, which is equal to K.

Input: N = 4, K = 10
Output: False

 

Approach: The problem can be solved based  on the following observation:

Suppose in a N size array having integers from 1 to N, there exist a subarray of size L, having minimum element M such that M * L = K. Therefore, M = K / L or K must be divisible by the length of the subarray. Also, M should be minimum element in subarray of size L

In a permutation of N integers, there are N – M + 1 elements, which are greater than or equal to M. So, for M to be minimum in subarray of size L, N – M + 1 ≥ L

Follow the steps mentioned below to implement the above idea:

  • Iterate the array from i = 1 to N
  • Let i be the length of subarray satisfying the required conditions.
    • Calculate the minimum element in the subarray.
    • As, L * M = K, so, M=K / L, (where M is the minimum element in current subarray)
  • Check if conditions stated in observation are satisfied or not i.e. M < N – L + 1.
  • If so, return true.

Below is the implementation of the above approach.

C++




// C++ code for above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function toCheck if there can be
// a subarray such that product of its
// length with its minimum element is K
bool isPossible(int N, int K)
{
    // Variable to store answer
    bool ans = true;
 
    for (int i = 1; i <= N; i++) {
 
        // Variable to store length of
        // current candidate subarray
        int length = i;
 
        // Since minimum element * length
        // of subarray should be K,
        // that means K should be divisible
        // by length of candidate subarray
        if (K % length == 0) {
 
            // Candidate for minimum element
            int min_element = K / length;
 
            // Checking if candidate for
            // minimum element can actually
            // be a minimum element in a
            // sequence on size "length"
            if (min_element < N - length + 1) {
                ans = true;
                break;
            }
        }
    }
 
    // Returning answer
    return ans;
}
 
// Driver code
int main()
{
    int N = 5;
    int K = 6;
 
    // Function call
    bool answer = isPossible(N, K);
    cout << boolalpha << answer;
    return 0;
}

Java




// JAVA code for above approach
import java.util.*;
class GFG
{
 
  // Function toCheck if there can be
  // a subarray such that product of its
  // length with its minimum element is K
  public static boolean isPossible(int N, int K)
  {
 
    // Variable to store answer
    boolean ans = true;
 
    for (int i = 1; i <= N; i++) {
 
      // Variable to store length of
      // current candidate subarray
      int length = i;
 
      // Since minimum element * length
      // of subarray should be K,
      // that means K should be divisible
      // by length of candidate subarray
      if (K % length == 0) {
 
        // Candidate for minimum element
        int min_element = K / length;
 
        // Checking if candidate for
        // minimum element can actually
        // be a minimum element in a
        // sequence on size "length"
        if (min_element < N - length + 1) {
          ans = true;
          break;
        }
      }
    }
 
    // Returning answer
    return ans;
  }
 
  // Driver code
  public static void main(String[] args)
  {
    int N = 5;
    int K = 6;
 
    // Function call
    boolean answer = isPossible(N, K);
    System.out.print(answer);
  }
}
 
// This code is contributed by Taranpreet

Python3




# Python3 code for above approach
 
# Function toCheck if there can be
# a subarray such that product of its
# length with its minimum element is K
def isPossible(N, K):
   
    # Variable to store answer
    ans = 1
 
    for i in range(1, N + 1):
 
        # Variable to store length of
        # current candidate subarray
        length = i
 
        # Since minimum element * length
        # of subarray should be K,
        # that means K should be divisible
        # by length of candidate subarray
        if (K % length == 0):
 
            # Candidate for minimum element
            min_element = K / length
 
            # Checking if candidate for
            # minimum element can actually
            # be a minimum element in a
            # sequence on size "length"
            if (min_element < N - length + 1):
                ans = 1
                break
 
    # Returning answer
    return ans
 
# Driver code
if __name__ == "__main__":
       
    N = 5
    K = 6
 
    # Function call
    answer = isPossible(N, K)
    print(bool(answer))
     
    # This code is contributed by hrithikgarg03188.

C#




// C# code for above approach
using System;
class GFG {
 
  // Function toCheck if there can be
  // a subarray such that product of its
  // length with its minimum element is K
  static bool isPossible(int N, int K)
  {
 
    // Variable to store answer
    bool ans = true;
 
    for (int i = 1; i <= N; i++) {
 
      // Variable to store length of
      // current candidate subarray
      int length = i;
 
      // Since minimum element * length
      // of subarray should be K,
      // that means K should be divisible
      // by length of candidate subarray
      if (K % length == 0) {
 
        // Candidate for minimum element
        int min_element = K / length;
 
        // Checking if candidate for
        // minimum element can actually
        // be a minimum element in a
        // sequence on size "length"
        if (min_element < N - length + 1) {
          ans = true;
          break;
        }
      }
    }
 
    // Returning answer
    return ans;
  }
 
  // Driver code
  public static void Main()
  {
    int N = 5;
    int K = 6;
 
    // Function call
    bool answer = isPossible(N, K);
    Console.Write(answer);
  }
}
 
// This code is contributed by Samim Hossain Mondal.

Javascript




<script>
       // JavaScript code for the above approach
 
       // Function toCheck if there can be
       // a subarray such that product of its
       // length with its minimum element is K
       function isPossible(N, K)
       {
        
           // Variable to store answer
           let ans = true;
 
           for (let i = 1; i <= N; i++) {
 
               // Variable to store length of
               // current candidate subarray
               let length = i;
 
               // Since minimum element * length
               // of subarray should be K,
               // that means K should be divisible
               // by length of candidate subarray
               if (K % length == 0) {
 
                   // Candidate for minimum element
                   let min_element = Math.floor(K / length);
 
                   // Checking if candidate for
                   // minimum element can actually
                   // be a minimum element in a
                   // sequence on size "length"
                   if (min_element < N - length + 1) {
                       ans = true;
                       break;
                   }
               }
           }
 
           // Returning answer
           return ans;
       }
 
       // Driver code
       let N = 5;
       let K = 6;
 
       // Function call
       let ans = isPossible(N, K);
       document.write(ans)
 
     // This code is contributed by Potta Lokesh
   </script>

 
 

Output

true

 

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

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!