Skip to content
Related Articles

Related Articles

Check if all objects of type A and B can be placed on N shelves

View Discussion
Improve Article
Save Article
  • Last Updated : 11 Feb, 2022

Given two integers A and B, representing the count of objects of two different types, and another integer N which represents the number of shelves, the task is to place all objects in the given N shelves abiding by the following rules: 
 

  • Any shelf cannot contain both Type-A and Type-B objects at the same time.
  • No shelf can contain more than K objects of Type-A or L objects of type B.

If it is possible to place all the items in N shelves, print “YES”. Otherwise, print “NO”.
Examples: 
 

Input: A = 3, B = 3, N = 3, K = 4, M = 2 
Output: YES 
Explanation: 
3 Type-A items can be placed on 1 shelf, as maximum limit is 4. 
3 Type-B items can be placed on 2 shelves, as maximum limit is 2. 
Since the required number of shelves does not exceed N, so allocation is possible.
Input: A = 6, B = 7, N = 3, K = 4, L = 5 
Output: NO 
Explanation: 
6 Type-A items require 2 shelves, as maximum limit is 4. 
7 Type-B items require 2 shelves, as maximum limit is 5. 
Since the required number of shelves exceeds N, so allocation is not possible. 
 

 

Approach: 
To solve the problem, we need to count the minimum number of shelves required to place all objects and check if it exceeds N or not. Follow the steps below: 
 

  • Count the minimum number of items required to place Type-A items, say needa. Since, K Type-A items can be placed at most in a single shelf, following two conditions arise: 
    1. If A is divisible by K, all Type-A items can be placed in A / K shelves.
    2. Otherwise, A % K items needs to be placed in 1 shelf and the rest in A / K shelves.Hence A/ K + 1 shelves are required for this case.
  • Similarly, calculate the minimum number of shelves required to place Type-B items, say needb
     
  • If needa + needb exceeds N, allocation is not possible. Otherwise, it is possible.

Below is the implementation of the above approach.
 

C++




// C++ implementation of the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to return if allocation
// is possible or not
bool isPossible(int A, int B, int N,
                int K, int L)
{
    // Stores the shelves needed
    // for items of type-A and type-B
    int needa, needb;
 
    // Find number of shelves
    // needed for items of type-A
    if (A % K == 0)
 
        // Fill A / K shelves fully
        // by the items of type-A
        needa = A / K;
 
    // Otherwise
    else
 
        // Fill A / L shelves fully
        // and add remaining to an
        // extra shelf
        needa = A / K + 1;
 
    // Find number of shelves
    // needed for items of type-B
    if (B % L == 0)
 
        // Fill B / L shelves fully
        // by the items of type-B
        needb = B / L;
 
    else
 
        // Fill B / L shelves fully
        // and add remaining to an
        // an extra shelf
        needb = B / L + 1;
 
    // Total shelves needed
    int total = needa + needb;
 
    // If required shelves exceed N
    if (total > N)
        return false;
    else
        return true;
}
 
// Driver Program
int main()
{
    int A = 3, B = 3, N = 3;
    int K = 4, M = 2;
 
    if (isPossible(A, B, N, K, M))
        cout << "YES" << endl;
    else
        cout << "NO" << endl;
 
    return 0;
}

Java




// Java implementation of the above approach
class GFG{
 
// Function to return if allocation
// is possible or not
static boolean isPossible(int A, int B,
                          int N, int K,
                          int L)
{
     
    // Stores the shelves needed
    // for items of type-A and type-B
    int needa, needb;
 
    // Find number of shelves
    // needed for items of type-A
    if (A % K == 0)
 
        // Fill A / K shelves fully
        // by the items of type-A
        needa = A / K;
 
    // Otherwise
    else
 
        // Fill A / L shelves fully
        // and add remaining to an
        // extra shelf
        needa = A / K + 1;
 
    // Find number of shelves
    // needed for items of type-B
    if (B % L == 0)
 
        // Fill B / L shelves fully
        // by the items of type-B
        needb = B / L;
 
    else
 
        // Fill B / L shelves fully
        // and add remaining to an
        // an extra shelf
        needb = B / L + 1;
 
    // Total shelves needed
    int total = needa + needb;
 
    // If required shelves exceed N
    if (total > N)
        return false;
    else
        return true;
}
 
// Driver code
public static void main(String[] args)
{
    int A = 3, B = 3, N = 3;
    int K = 4, M = 2;
 
    if (isPossible(A, B, N, K, M))
        System.out.print("YES" + "\n");
    else
        System.out.print("NO" + "\n");
}
}
 
// This code is contributed by amal kumar choubey

Python3




# Python3 implementation of the
# above approach
 
# Function to return if allocation
# is possible or not
def isPossible(A, B, N, K, L):
     
    # Stores the shelves needed
    # for items of type-A and type-B
    needa = 0
    needb = 0
 
    # Find number of shelves
    # needed for items of type-A
    if (A % K == 0):
 
        # Fill A / K shelves fully
        # by the items of type-A
        needa = A // K;
 
    # Otherwise
    else:
 
        # Fill A / L shelves fully
        # and add remaining to an
        # extra shelf
        needa = A // K + 1
 
    # Find number of shelves
    # needed for items of type-B
    if (B % L == 0):
 
        # Fill B / L shelves fully
        # by the items of type-B
        needb = B // L
 
    else:
 
        # Fill B / L shelves fully
        # and add remaining to an
        # an extra shelf
        needb = B // L + 1
 
    # Total shelves needed
    total = needa + needb
 
    # If required shelves exceed N
    if (total > N):
        return False
    else:
        return True
 
# Driver Code       
if __name__=='__main__':
     
    A, B, N = 3, 3, 3
    K, M = 4, 2
 
    if (isPossible(A, B, N, K, M)):
        print('YES')
    else:
        print('NO')
 
# This code is contributed by rutvik_56

C#




// C# implementation of the above approach
using System;
 
class GFG{
 
// Function to return if allocation
// is possible or not
static bool isPossible(int A, int B,
                       int N, int K,
                       int L)
{
     
    // Stores the shelves needed
    // for items of type-A and type-B
    int needa, needb;
 
    // Find number of shelves
    // needed for items of type-A
    if (A % K == 0)
 
        // Fill A / K shelves fully
        // by the items of type-A
        needa = A / K;
 
    // Otherwise
    else
 
        // Fill A / L shelves fully
        // and add remaining to an
        // extra shelf
        needa = A / K + 1;
 
    // Find number of shelves
    // needed for items of type-B
    if (B % L == 0)
 
        // Fill B / L shelves fully
        // by the items of type-B
        needb = B / L;
 
    else
 
        // Fill B / L shelves fully
        // and add remaining to an
        // an extra shelf
        needb = B / L + 1;
 
    // Total shelves needed
    int total = needa + needb;
 
    // If required shelves exceed N
    if (total > N)
        return false;
    else
        return true;
}
 
// Driver code
public static void Main(String[] args)
{
    int A = 3, B = 3, N = 3;
    int K = 4, M = 2;
 
    if (isPossible(A, B, N, K, M))
        Console.Write("YES" + "\n");
    else
        Console.Write("NO" + "\n");
}
}
 
// This code is contributed by Rohit_ranjan

Javascript




<script>
 
// JavaScript program to implement
// the above approach
 
// Function to return if allocation
// is possible or not
function isPossible(A, B, N, K, L)
{
       
    // Stores the shelves needed
    // for items of type-A and type-B
    let needa, needb;
   
    // Find number of shelves
    // needed for items of type-A
    if (A % K == 0)
   
        // Fill A / K shelves fully
        // by the items of type-A
        needa =  Math.floor(A / K);
   
    // Otherwise
    else
   
        // Fill A / L shelves fully
        // and add remaining to an
        // extra shelf
        needa =  Math.floor(A / K) + 1;
   
    // Find number of shelves
    // needed for items of type-B
    if (B % L == 0)
   
        // Fill B / L shelves fully
        // by the items of type-B
        needb = Math.floor(B / L);
   
    else
   
        // Fill B / L shelves fully
        // and add remaining to an
        // an extra shelf
        needb =  Math.floor(B / L) + 1;
   
    // Total shelves needed
    let total = needa + needb;
   
    // If required shelves exceed N
    if (total > N)
        return false;
    else
        return true;
}
 
// Driver code
 
    let A = 3, B = 3, N = 3;
    let K = 4, M = 2;
   
    if (isPossible(A, B, N, K, M))
        document.write("YES" + "<br/>");
    else
        document.write("NO" + "<br/>");
 
// This code is contributed by sanjoy_62.
</script>

Output: 

YES

 

Time complexity: O(1) 
Auxiliary Space: O(1)
 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!