Arranging Tasks within a specified duration Algorithmic puzzle - algorithm

Question

I have an interesting DS problem, I have a fixed duration (1 hour) and a variable duration (1 to 2 hours) and I am given a certain number of tasks as detailed below. How would I find the correct multiple grouping of tasks such that they sum up to the specified durations.
Task examples: -
Task A - 25 min,
Task B - 20 min,
Task C - 25 min,
Task D - 35 min.
Task E - 25 min,
Task F - 30 min,
Task G - 30 min.
For the 1 hour duration, a sample answer would be : -
Task F + G
Task D + E
For the 1 to 2 hour duration, a sample answer would be : -
Task F + G
Task A + B + C
The proper algorithm would help me to identify all combindations.

Answer 1

Try this
from itertools import chain, combinations
tasks = {
"A": 25,
"B": 20,
"C": 25,
"D": 35,
"E": 25,
"F": 30,
"G": 30
}
def powerset(iterable):
s = list(iterable)
return chain.from_iterable(combinations(s, r) for r in range(len(s) + 1))
def get_possible_tasks(fixed_duration):
for comb in powerset(tasks):
if sum([tasks[i] for i in comb]) == fixed_duration:
yield comb
def get_possible_tasks_inrange(min_duration, max_duration):
for comb in powerset(tasks):
if min_duration <= sum([tasks[i] for i in comb]) <= max_duration:
yield comb
print("TASKS completed in onehour")
for i in get_possible_tasks(60):
print(i)
print("TASKS In RANGE 60-120 minutes")
for i in get_possible_tasks_inrange(60,120):
print(i)
Output:
TASKS completed in onehour
('A', 'D')
('C', 'D')
('D', 'E')
('F', 'G')
TASKS In RANGE 60-120 minutes
('A', 'D')
('C', 'D')
('D', 'E')
('D', 'F')
('D', 'G')
('F', 'G')
('A', 'B', 'C')
('A', 'B', 'D')
('A', 'B', 'E')
('A', 'B', 'F')
('A', 'B', 'G')
('A', 'C', 'D')
('A', 'C', 'E')
('A', 'C', 'F')
('A', 'C', 'G')
('A', 'D', 'E')
('A', 'D', 'F')
('A', 'D', 'G')
('A', 'E', 'F')
('A', 'E', 'G')
('A', 'F', 'G')
('B', 'C', 'D')
('B', 'C', 'E')
('B', 'C', 'F')
('B', 'C', 'G')
('B', 'D', 'E')
('B', 'D', 'F')
('B', 'D', 'G')
('B', 'E', 'F')
('B', 'E', 'G')
('B', 'F', 'G')
('C', 'D', 'E')
('C', 'D', 'F')
('C', 'D', 'G')
('C', 'E', 'F')
('C', 'E', 'G')
('C', 'F', 'G')
('D', 'E', 'F')
('D', 'E', 'G')
('D', 'F', 'G')
('E', 'F', 'G')
('A', 'B', 'C', 'D')
('A', 'B', 'C', 'E')
('A', 'B', 'C', 'F')
('A', 'B', 'C', 'G')
('A', 'B', 'D', 'E')
('A', 'B', 'D', 'F')
('A', 'B', 'D', 'G')
('A', 'B', 'E', 'F')
('A', 'B', 'E', 'G')
('A', 'B', 'F', 'G')
('A', 'C', 'D', 'E')
('A', 'C', 'D', 'F')
('A', 'C', 'D', 'G')
('A', 'C', 'E', 'F')
('A', 'C', 'E', 'G')
('A', 'C', 'F', 'G')
('A', 'D', 'E', 'F')
('A', 'D', 'E', 'G')
('A', 'D', 'F', 'G')
('A', 'E', 'F', 'G')
('B', 'C', 'D', 'E')
('B', 'C', 'D', 'F')
('B', 'C', 'D', 'G')
('B', 'C', 'E', 'F')
('B', 'C', 'E', 'G')
('B', 'C', 'F', 'G')
('B', 'D', 'E', 'F')
('B', 'D', 'E', 'G')
('B', 'D', 'F', 'G')
('B', 'E', 'F', 'G')
('C', 'D', 'E', 'F')
('C', 'D', 'E', 'G')
('C', 'D', 'F', 'G')
('C', 'E', 'F', 'G')
('D', 'E', 'F', 'G')

Answer 2

static void showCombinations(int flag,List<String> task,int sum,int start, List<Integer> arr, int n, int r, int eAdded, List<Integer> data, List<Integer> endList) {
int k = start + 1;
if (eAdded == r) {
int temp=0;
for(int i=0;i<data.size();i++){
temp+=data.get(i);
}
if(temp==sum&&flag==0){
task.forEach((it)->{
System.out.print(it);
});
System.out.println();
}
else if(temp>=sum && temp<=120&&flag==1){
task.forEach((it)->{
System.out.print(it);
});
System.out.println();
}
} else {
for (int i = start; i <= endList.get(eAdded); i++) {
data.add(arr.get(i));
task.add(Character.toString((char) (i+ 65)));
showCombinations(flag,task,sum,k, arr, n, r, eAdded + 1, data, endList);
task.remove(task.size() - 1);
data.remove(data.size() - 1);
k++;
}
}
}
public static void main(String args[]){
List<Integer> resultList = new ArrayList<>();
ArrayList<ArrayList<Integer>> values = new ArrayList<>();
List<Integer> data = new ArrayList<>();
resultList.add(25); // For each element in resultList the element is
resultList.add(20); // taken by a particular task
resultList.add(25); //
resultList.add(35); //
resultList.add(25); //
resultList.add(30); //
resultList.add(30); //
int n=resultList.size();
List<Integer> end = new ArrayList<>();// List that contains end value for each starting index
List<String> task=new ArrayList<>();
System.out.println("These completes within an hour: ");
for(int k=1;k<=resultList.size();k++){
for (int i = 0; i <= k; i++) {
end.add(n - (k) + i);
}
showCombinations(0,task, 60, 0, resultList, resultList.size(), k, 0, data, end);
data.clear();
end.clear();
task.clear();
}
System.out.println("These completes within 1 to 2 hour(both Inclusive) : ");
for(int k=1;k<=resultList.size();k++){
for (int i = 0; i <= k; i++) {
end.add(n - (k) + i);
}
showCombinations(1,task, 60, 0, resultList, resultList.size(), k, 0, data, end);
data.clear();
end.clear();
task.clear();
}
}
Output:
These completes within an hour:
AD
CD
DE
FG
These completes within 1 to 2 hour(both Inclusive) :
AD
CD
DE
DF
DG
FG
ABC
ABD
ABE
ABF
ABG
ACD
ACE
ACF
ACG
ADE
ADF
ADG
AEF
AEG
AFG
BCD
BCE
BCF
BCG
BDE
BDF
BDG
BEF
BEG
BFG
CDE
CDF
CDG
CEF
CEG
CFG
DEF
DEG
DFG
EFG
ABCD
ABCE
ABCF
ABCG
ABDE
ABDF
ABDG
ABEF
ABEG
ABFG
ACDE
ACDF
ACDG
ACEF
ACEG
ACFG
ADEF
ADEG
ADFG
AEFG
BCDE
BCDF
BCDG
BCEF
BCEG
BCFG
BDEF
BDEG
BDFG
BEFG
CDEF
CDEG
CDFG
CEFG
DEFG