Given length of wall w and shelves of two lengths m and n, find the number of each type of shelf to be used and the remaining empty space in the optimal solution so that the empty space is minimum. The larger of the two shelves is cheaper so it is preferred. However cost is secondary and first priority is to minimize empty space on wall.
Examples:
Input : w = 24 m = 3 n = 5
Output : 3 3 0
We use three units of both shelves
and 0 space is left.
3 * 3 + 3 * 5 = 24
So empty space = 24 - 24 = 0
Another solution could have been 8 0 0
but since the larger shelf of length 5
is cheaper the former will be the answer.
Input : w = 29 m = 3 n = 9
Output : 0 3 2
0 * 3 + 3 * 9 = 27
29 - 27 = 2
Input : w = 24 m = 4 n = 7
Output : 6 0 0
6 * 4 + 0 * 7 = 24
24 - 24 = 0
A simple and efficient approach will be to try all possible combinations of shelves that fit within the length of the wall.
To implement this approach along with the constraint that larger shelf costs less than the smaller one, starting from 0, we increase no of larger type shelves till they can be fit. For each case we calculate the empty space and finally store that value which minimizes the empty space. if empty space is same in two cases we prefer the one with more no of larger shelves.
Below is its implementation.
C++
#include <bits/stdc++.h>
using namespace std;
void minSpacePreferLarge( int wall, int m, int n)
{
int num_m = 0, num_n = 0, min_empty = wall;
int p = wall/m, q = 0, rem=wall%m;
num_m=p;
num_n=q;
min_empty=rem;
while (wall >= n) {
q += 1;
wall = wall - n;
p = wall / m;
rem = wall % m;
if (rem <= min_empty) {
num_m = p;
num_n = q;
min_empty = rem;
}
}
cout << num_m << " " << num_n << " "
<< min_empty << endl;
}
int main()
{
int wall = 29, m = 3, n = 9;
minSpacePreferLarge(wall, m, n);
wall = 76, m = 1, n = 10;
minSpacePreferLarge(wall, m, n);
return 0;
}
|
C
#include <stdio.h>
void minSpacePreferLarge( int wall, int m, int n)
{
int num_m = 0, num_n = 0, min_empty = wall;
int p = wall / m, q = 0, rem = wall % m;
num_m = p;
num_n = q;
min_empty = rem;
while (wall >= n) {
q += 1;
wall = wall - n;
p = wall / m;
rem = wall % m;
if (rem <= min_empty) {
num_m = p;
num_n = q;
min_empty = rem;
}
}
printf ( "%d %d %d\n" , num_m, num_n, min_empty);
}
int main()
{
int wall = 29, m = 3, n = 9;
minSpacePreferLarge(wall, m, n);
wall = 76, m = 1, n = 10;
minSpacePreferLarge(wall, m, n);
return 0;
}
|
Java
public class GFG {
static void minSpacePreferLarge( int wall, int m, int n)
{
int num_m = 0 , num_n = 0 , min_empty = wall;
int p = wall/m, q = 0 , rem=wall%m;
num_m=p;
num_n=q;
min_empty=rem;
while (wall >= n) {
q += 1 ;
wall = wall - n;
p = wall / m;
rem = wall % m;
if (rem <= min_empty) {
num_m = p;
num_n = q;
min_empty = rem;
}
q += 1 ;
wall = wall - n;
}
System.out.println(num_m + " " + num_n + " " + min_empty);
}
public static void main(String[] args)
{
int wall = 24 , m = 3 , n = 5 ;
minSpacePreferLarge(wall, m, n);
wall = 24 ;
m = 4 ;
n = 7 ;
minSpacePreferLarge(wall, m, n);
}
}
|
Python3
def minSpacePreferLarge(w, m, n):
num_m = 0
num_n = 0
rem = w
p = w / / m
q = 0
rem = w % m;
num_m = p;
num_n = q;
min_empty = rem;
while (w > = n):
q + = 1 ;
w - = n;
p = w / / m
r = w % m
if (r < = rem):
num_m = p
num_n = q
rem = r
q + = 1
w - = n
print ( str ( int (num_m)) + " " + str (num_n) + " " + str (rem))
w = 24
m = 3
n = 5
minSpacePreferLarge(w, m, n)
w = 24
m = 4
n = 7
minSpacePreferLarge(w, m, n)
|
C#
using System;
class GFG {
static void minSpacePreferLarge( int wall, int m, int n)
{
int num_m = 0, num_n = 0, min_empty = wall;
int p = wall/m, q = 0, rem=wall%m;
num_m=p;
num_n=q;
min_empty=rem;
while (wall >= n) {
q += 1;
wall = wall - n;
p = wall / m;
rem = wall % m;
if (rem <= min_empty) {
num_m = p;
num_n = q;
min_empty = rem;
}
q += 1;
wall = wall - n;
}
Console.WriteLine(num_m + " " + num_n + " " + min_empty);
}
static public void Main()
{
int wall = 24, m = 3, n = 5;
minSpacePreferLarge(wall, m, n);
wall = 24;
m = 4;
n = 7;
minSpacePreferLarge(wall, m, n);
}
}
|
PHP
<?php
function minSpacePreferLarge( $wall , $m , $n )
{
$num_m = 0;
$num_n = 0;
$min_empty = $wall ;
$p = $wall / $m
$q = 0
$rem = $wall % $m ;
$num_m = $p ;
$num_n = $q ;
$min_empty = $rem ;
while ( $wall >= $n )
{
$q += 1;
$wall = $wall - $n ;
$p = $wall / $m ;
$rem = $wall % $m ;
if ( $rem <= $min_empty )
{
$num_m = $p ;
$num_n = $q ;
$min_empty = $rem ;
}
$q += 1;
$wall = $wall - $n ;
}
echo $num_m , " " , $num_n , " " ,
$min_empty , "\n" ;
}
$wall = 24;
$m = 3;
$n = 5;
minSpacePreferLarge( $wall , $m , $n );
$wall = 24;
$m = 4;
$n = 7;
minSpacePreferLarge( $wall , $m , $n );
?>
|
Javascript
<script>
function minSpacePreferLarge(wall, m, n)
{
let num_m = 0, num_n = 0, min_empty = wall;
let p = parseInt(wall/m, 10), q = 0, rem=wall%m;
num_m=p;
num_n=q;
min_empty=rem;
while (wall >= n) {
q += 1;
wall = wall - n;
p = parseInt(wall / m, 10);
rem = wall % m;
if (rem <= min_empty) {
num_m = p;
num_n = q;
min_empty = rem;
}
}
document.write(num_m + " " + num_n + " " + min_empty + "</br>" );
}
let wall = 29, m = 3, n = 9;
minSpacePreferLarge(wall, m, n);
wall = 76, m = 1, n = 10;
minSpacePreferLarge(wall, m, n);
</script>
|
Time Complexity: O(w/max(n,m))
Space Complexity: O(1)
References: Sumologic Internship question
Last Updated :
11 Jun, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...