CareerCup

The idea is to accommodate "cheapest" tasks first using a cpu with the least free cores.

def count(tasks, cpus):
    tasks = sorted(tasks)
    heapq.heapify(cpus)
    res = 0
    for t in tasks:
        while cpus and cpus[0] < t:
            heapq.heappop(cpus)
        if not cpus:
            return res
        cores = cpus[0]
        res += 1
        heapq.heapreplace(cpus, cores - t)
    return res

def count(tasks, cpus):
tasks = sorted(tasks)
heapq.heapify(cpus)
res = 0
for t in tasks:
while cpus and cpus[0] < t:
heapq.heappop(cpus)
if not cpus:
return res
cores = cpus[0]
res += 1
heapq.heapreplace(cpus, cores - t)
return res

public class AIQ {
    public static void main(String args[]) {
        int process[] = {3,5,7};
        int core[] = {1,3,5};
        
        System.out.println(findMaxProcessAllocation(process,core));
    }
    
    public static int findMaxProcessAllocation(int[] process,int[] core){
        int maxCore = findMaxCore(core);
        int result = 0;
        for(int i=0;i<process.length;i++){
            if(process[i] <= maxCore){
                result++;
            }
        }
        return result;
    }
    
    public static int findMaxCore(int[] core){
        int max = 0;
        for(int i=0;i<core.length;i++){
            if(core[i] > max){
                max = core[i];
            }
        }
        return max;
    }
}

public class AIQ {
    public static void main(String args[]) {
        int process[] = {3,5,7};
        int core[] = {1,3,5};
        
        System.out.println(findMaxProcessAllocation(process,core));
    }
    
    public static int findMaxProcessAllocation(int[] process,int[] core){
        int maxCore = findMaxCore(core);
        int result = 0;
        for(int i=0;i<process.length;i++){
            if(process[i] <= maxCore){
                result++;
            }
        }
        return result;
    }
    
    public static int findMaxCore(int[] core){
        int max = 0;
        for(int i=0;i<core.length;i++){
            if(core[i] > max){
                max = core[i];
            }
        }
        return max;
    }
}

public class AIQ {
public static void main(String args[]) {
int process[] = {3,5,7};
int core[] = {1,3,5};

System.out.println(findMaxProcessAllocation(process,core));
}

public static int findMaxProcessAllocation(int[] process,int[] core){
int maxCore = findMaxCore(core);
int result = 0;
for(int i=0;i<process.length;i++){
if(process[i] <= maxCore){
result++;
}
}
return result;
}

public static int findMaxCore(int[] core){
int max = 0;
for(int i=0;i<core.length;i++){
if(core[i] > max){
max = core[i];
}
}
return max;
}
}

and

public class AIQ {
public static void main(String args[]) {
int process[] = {3,5,7};
int core[] = {1,3,5};

System.out.println(findMaxProcessAllocation(process,core));
}

public static int findMaxProcessAllocation(int[] process,int[] core){
int maxCore = findMaxCore(core);
int result = 0;
for(int i=0;i<process.length;i++){
if(process[i] <= maxCore){
result++;
}
}
return result;
}

public static int findMaxCore(int[] core){
int max = 0;
for(int i=0;i<core.length;i++){
if(core[i] > max){
max = core[i];
}
}
return max;
}
}

and

public class AIQ {
public static void main(String args[]) {
int process[] = {3,5,7};
int core[] = {1,3,5};

System.out.println(findMaxProcessAllocation(process,core));
}

public static int findMaxProcessAllocation(int[] process,int[] core){
int maxCore = findMaxCore(core);
int result = 0;
for(int i=0;i<process.length;i++){
if(process[i] <= maxCore){
result++;
}
}
return result;
}

public static int findMaxCore(int[] core){
int max = 0;
for(int i=0;i<core.length;i++){
if(core[i] > max){
max = core[i];
}
}
return max;
}
}

and

public static int findMaxProcessAllocation(int[] process,int[] core){
int maxCore = findMaxCore(core);
int result = 0;
for(int i=0;i<process.length;i++){
if(process[i] <= maxCore){
result++;
}
}
return result;
}

This problem cab solved by applying solution for maximum bipartite graph problem.