Consolidating partitions / aka Compaction algorithm - arrays

Question

Given number of partitons (usedSpace and its totalSpace) of a hard disk in the form of an list
Example usedSpace = [3,2,1,3,1]
totalSpace = [3,5,3,5,5]
Here usedSpace is the partition getting used out of total space on that partition.
Find the minimum number of partitions need to hold all the data if we move data around partition optimally.
In this cases
a) move data from 1st partion to 2nd partition and 1st partition will be empty
b) move data of 3rd and 5th partition to 4th partition and 3rd and 5th will be free.
Hence only 2 partition needed to hold all the data.

Answer 1

Since the number of moves doesn't matter, and since data can be split up, a greedy approach will work. Pseudocode:
partitionCount := 0
# We're only worried about the total space used vs the total space available
unallocatedDataSize := sum of elements in usedSpace
# Greedily use the largest available space
sort totalSpace by size, descending
while unallocatedDataSize > 0 and totalSpace is not empty
partitionSize := totalSpace.removeFirst()
partitionCount := partitionCount + 1
# Storing partitionSize data in this partition, remove it from our tracking
unallocatedDataSize = unallocatedDataSize - partitionSize
return partitionCount

Answer 2

An optimal and working solution in C#:
public int getMinDrives(int[] used, int[] total)
{
int hdQty = 1;
int pos = 0;
int currentTotal;
Array.Sort(total);
Array.Reverse(total);
int usedSum = used.Sum();
while (usedSum > 0)
{
currentTotal = total[pos];
usedSum = usedSum - currentTotal;
if (usedSum > 0)
{
hdQty++;
pos++;
continue;
}
}
return hdQty;
}

Answer 3

How this can be resolved by Java, if the function returning as Integer value containing args of the amount of used space on each partition and total capacity of each partition, like :
int minPartition(List<Integer> used, List<Integer> totalCapacity), how one can resolve by the above answer supplied by Greedy approach?
The below code responds to Heap space error if i checked with above:
import java.util.ArrayList;
import java.util.List;
public class Program3 {
public static void main(String[] args) {
List<Integer> used = new ArrayList<>();
List<Integer> totalCapacity = new ArrayList<>();
used.add(1);
used.add(2);
used.add(3);
totalCapacity.add(3);
totalCapacity.add(3);
totalCapacity.add(3);
System.out.println(minPartitions(used,totalCapacity));
}
public static int minPartitions(List<Integer> used, List<Integer> totalCapacity) {
// Write your code here
int sizeOfUsedPartion = used.size();
int sizeOfMemoryUsed = totalCapacity.size();
List<Integer> newMemory = new ArrayList<>();
while(sizeOfMemoryUsed != 0)
{
for(int i=0; i<sizeOfUsedPartion;i++)
{
for(int j=0; j<i;j++)
{
if((used.get(i)+used.get(j)) <= totalCapacity.get(i))
{
newMemory.add((used.get(i)+used.get(j)));
break;
}
}
}
}
return newMemory.size();
}
}

Answer 4

//You can use greedy approach. The below code is in c++.
#include<bits/stdc++.h>
using namespace std;
int minParts(vector<int>usedSpace,vector<int>totalSpace){
int q;
q=totalSpace.size();
sort(usedSpace.begin(),usedSpace.end());
sort(totalSpace.begin(),totalSpace.end());
int used=accumulate(usedSpace.begin(),usedSpace.end(),0);
int min=0;
for(int i=q-1;i>=0;i--){
if(used<=totalSpace[i]){
min=min+1;
break;
}
else{
used=used-totalSpace[i];
min=min+1;
}
}
return min;
}
int main(){
vector<int>usedSpace={3,2,1,3,1};
vector<int>totalSpace={3,5,3,5,5};
int m=minParts(usedSpace,totalSpace);
cout<<m;
return 0;
}
//modify the code to give user input
//I could not find a better approach